使用Chrome浏览器打开指定html文件

例如，我想使用chrome打开当前路径下的index.html文件,可以输入如下命令:

1

"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" index.html

命令解释:

• "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"这个是谷歌浏览器(chrome)的绝对路径,因为路径中间有空格,最好用括号包裹起来。
• index.html这个是html文件的相对路径。

创建批处理脚本chrome.bat来打开html文件

创建chrome.bat文件,在其中写入:

1
2

@echo off
"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" %1

命令解释:

• @echo off不显示正在运行的命令。
• "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"谷歌浏览器路径，以你的为准
• %1这个表示第一个命令行参数,也就是文件名
  然后现在只需要输入chrome.bat index.html就可以完成上述功能了,甚至.bat也可以省略,只需要输入chrome index.html即可。

  chrome.bat配置到path环境变量中

  为了在所有的目录下都可以使用chrome.bat来打来html文件,还需要把chrome.bat的绝对路径配置到path环境变量中。

删除文件 del或erase命令

del命令用于删除一个或多个文件，帮助文档如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

c:\users\lan>del /?
删除一个或数个文件。
del [/p] [/f] [/s] [/q] [/a[[:]attributes]] names
erase [/p] [/f] [/s] [/q] [/a[[:]attributes]] names
  names         指定一个或多个文件或者目录列表。
                通配符可用来删除多个文件。
                如果指定了一个目录，该目录中的所
                有文件都会被删除。
  /p            删除每一个文件之前提示确认。
  /f            强制删除只读文件。
  /s            删除所有子目录中的指定的文件。
  /q            安静模式。删除全局通配符时，不要求确认
  /a            根据属性选择要删除的文件
  属性          r  只读文件                     s  系统文件
                h  隐藏文件                     a  存档文件
                i  无内容索引文件               l  重分析点
                -  表示“否”的前缀
如果命令扩展被启用，del 和 erase 更改如下:
/s 开关的显示句法会颠倒，即只显示已经删除的文件，而不显示找不到的文件。

删除 当前目录 下某个文件

输入del 文件名即可删除该文件，如:del a.txt。

删除 当前目录 下某个后缀的所有文件

输入del *.后缀名就可以删除以后该缀名的所有文件，如要删除掉当前目录下所的所有.html文件:

1

del *.html

删除掉当前目录下的所有.html,.js,.css文件:

1

del *.html *.js *.css

同时，从帮助文档中，我们可以看到，erase命令和del命令的功能一样，所以使用：

1

erase *.html *.js *.css

一样能删除当前目录下的所有.html,.js,.css文件。

删除 当前目录树 下某个后缀的所有文件

首先是要先cd到该目录下,然后再该目录下使用for命令进行删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@echo off
G:
echo ############################################################### 进入G盘
echo.
cd G:\Desktop\语音合成
echo ############################################################### 进入语音合成目录:%cd%
echo.
echo ############################################################### 删除所有的pcm文件
echo.
for /r . %%i in (*.pcm) do (
    echo     删除:"%%i"
    del "%%i"
)
echo.
echo ############################################################### 删除所有的xmp文件
echo.
for /r . %%i in (*.xmp) do (
    echo     删除:"%%i"
    del "%%i"
)
pause

测试

现在目录结构如下:

1
2
3
4
5

G:\Desktop\语音合成\神儒玄章>mytree f
G:\Desktop\语音合成\神儒玄章
├─神儒玄章.mp3
├─神儒玄章.pcm
└─神儒玄章.xmp

然后运行上面批处理脚本删除文件，程序输出如下:

1
2
3
4
5
6
7
8
9
10
11
12

############################################################## 进入G盘

############################################################## 进入语音合成目录:G:\Desktop\语音合成

############################################################## 删除所有的pcm文件

    删除:"G:\Desktop\语音合成\神儒玄章\神儒玄章.pcm"

############################################################## 删除所有的xmp文件

    删除:"G:\Desktop\语音合成\神儒玄章\神儒玄章.xmp"
请按任意键继续. . .

然后再从查看当前目录,可以看到.pcm后缀和.xmp后缀的文件都没删除掉了.

1
2
3

G:\Desktop\语音合成\神儒玄章>mytree f
G:\Desktop\语音合成\神儒玄章
└─神儒玄章.mp3

删除目录 rmdir或rd命令

rmdir命令用于删除一个目录，cmd中输入rmdir /?查看帮助文档，如下所示:

1
2
3
4
5
6

c:\users\lan>rmdir /?
删除一个目录。
rmdir [/s] [/q] [drive:]path
rd [/s] [/q] [drive:]path
    /s      除目录本身外，还将删除指定目录下的所有子目录和文件。用于删除目录树。
    /q      安静模式，带 /s 删除目录树时不要求确认

同样的,rd命令和rmdir命令一样。以后就直接使用rd命令这样可以少打几次键盘。

删除空目录

如果一个目录时空目录的话，则可以直接使用 rmdir 目录名直接删除即可：
例如:rmdir myjavadoc,如果该目录不是空目录则这样无法删除:

1
2

D:\学习9\疯狂Java讲义第三版光盘\codes\03\3.1>rmdir myjavadoc
目录不是空的。

删除非空目录

删除非空目录，需要加上/s参数:

1

rmdir /s myjavadoc

不过为了避免误操作，使用这个命令时,还需要我们输入y进行确认.

1
2

D:\学习9\疯狂Java讲义第三版光盘\codes\03\3.1>rmdir /s myjavadoc
myjavadoc, 是否确认(Y/N)? y

直接删除非空目录

如果删除非空目录时，不想再确认，则可以加上/q参数：

1

rmdir /q /s myjavadoc

这样就直接删除掉非空目录myjavadoc了。
当然如果myjavadoc目录时空目录的话加上参数也是能删掉的，但是空目录的话不加参数就可以删掉，加上参数反而画蛇添足。

如何cmd命令帮助文档

在命令后面输入 /?即可查看帮助文档,注意斜杠前面有个空格。

copy命令

先来查看copy命令的帮助文档：copy /?:

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

C:\Users\lan>copy /?
将一份或多份文件复制到另一个位置。
COPY [/D] [/V] [/N] [/Y | /-Y] [/Z] [/L] [/A | /B ] source [/A | /B]
     [+ source [/A | /B] [+ ...]] [destination [/A | /B]]
  source       指定要复制的文件。
  /A           表示一个 ASCII 文本文件。
  /B           表示一个二进位文件。
  /D           允许解密要创建的目标文件
  destination  为新文件指定目录和/或文件名。
  /V           验证新文件写入是否正确。
  /N           复制带有非 8dot3 名称的文件时，
               尽可能使用短文件名。
  /Y           不使用确认是否要覆盖现有目标文件
               的提示。
  /-Y          使用确认是否要覆盖现有目标文件
               的提示。
  /Z           用可重新启动模式复制已联网的文件。
/L           如果源是符号链接，请将链接复制
               到目标而不是源链接指向的实际文件。
命令行开关 /Y 可以在 COPYCMD 环境变量中预先设定。
这可能会被命令行上的 /-Y 替代。除非 COPY
命令是在一个批处理脚本中执行的，默认值应为
在覆盖时进行提示。
要附加文件，请为目标指定一个文件，为源指定
数个文件(用通配符或 file1+file2+file3 格式)。

可以看到copy命令是用来复制文件的。

实例

直接覆盖同名文件

如果D盘根目录下已经存在了一个名为test.txt的文件，那么，复制过去的时候，copy命令就会提示你是覆盖原文件、是放弃复制还是覆盖所有文件。如果你在批量复制的时候，一概覆盖原文件，那么，一个一个地选择十分麻烦，这个时候，你可以使用不加提示就覆盖原文件的参数 /y （相当于自动选择了Yes选项），完整的命令为：copy /y d:\test\test.txt d:\testcopy

复制改名

如果复制的时候，你还需要把源文件改个名，比如把test.txt改为1.txt的时候，可以直接使用：copy d:\test\test.txt d:\testcopy\1.txt 这样的命令，也就是说，在指定目的路径的时候，直接指定文件名，那么，新的文件名就是源文件复制之后的名字。

路径中带空格等特殊符号

如果要复制的路径带有空格、&等特殊符号的时候，请使用引号把这些特殊字符括起来，比如:copy "d:\test abc\test.txt" "d:\test&copy"

合并文件

copy命令除了“复制”文件的功能外，还有一个绝活：合并多个文件为一个文件，具体的格式为：
copy 文件1+文件2+文件3+…… 目的路径\新文件名 。例如：copy d:\test.txt+d:\abc.txt d:\test\test.txt，那么，就把D盘根目录下的test.txt和abc.txt两个文件的内容合并为test.txt，并保存到d:\test目录下。

必须注意的是，copy只能复制文件，对于文件夹的复制，则需要另请高明，动用xcopy来复制。xcopy是copy的高级版本，有更丰富的参数，能实现更加复杂的功能，通吃文件和文件夹的复制。

xcopy命令

还是先查看帮助文档，xcopy /?：

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

C:\Users\lan>xcopy /?
复制文件和目录树。
XCOPY source [destination] [/A | /M] [/D[:date]] [/P] [/S [/E]] [/V] [/W]
                           [/C] [/I] [/Q] [/F] [/L] [/G] [/H] [/R] [/T] [/U]
                           [/K] [/N] [/O] [/X] [/Y] [/-Y] [/Z] [/B] [/J]
                           [/EXCLUDE:file1[+file2][+file3]...]
  source       指定要复制的文件。
  destination  指定新文件的位置和/或名称。
  /A           仅复制有存档属性集的文件，
               但不更改属性。
  /M           仅复制有存档属性集的文件，
               并关闭存档属性。
  /D:m-d-y     复制在指定日期或指定日期以后更改的文件。
               如果没有提供日期，只复制那些
               源时间比目标时间新的文件。
  /EXCLUDE:file1[+file2][+file3]...
               指定含有字符串的文件列表。每个字符串
               在文件中应位于单独的一行。如果任何
               字符串与复制文件的绝对路径的任何部分相符，
               则排除复制该文件。例如，
               指定如 \obj\ 或 .obj 的字符串会分别
               排除目录 obj 下面的所有文件或带有
               .obj 扩展名的所有文件。
  /P           创建每个目标文件之前提示你。
  /S           复制目录和子目录，不包括空目录。
  /E           复制目录和子目录，包括空目录。
               与 /S /E 相同。可以用来修改 /T。
  /V           验证每个新文件的大小。
  /W           提示你在复制前按键。
  /C           即使有错误，也继续复制。
  /I           如果目标不存在，且要复制多个文件，
               则假定目标必须是目录。
  /Q           复制时不显示文件名。
  /F           复制时显示完整的源文件名和目标文件名。
  /L           显示要复制的文件。
  /G           允许将加密文件复制到
               不支持加密的目标。
  /H           也复制隐藏文件和系统文件。
  /R           覆盖只读文件。
  /T           创建目录结构，但不复制文件。不
               包括空目录或子目录。/T /E 包括
               空目录和子目录。
  /U           只复制已经存在于目标中的文件。
  /K           复制属性。一般的 Xcopy 会重置只读属性。
  /N           用生成的短名称复制。
  /O           复制文件所有权和 ACL 信息。
  /X           复制文件审核设置(隐含 /O)。
  /Y           取消提示以确认要覆盖
               现有目标文件。
  /-Y          要提示以确认要覆盖
               现有目标文件。
  /Z           在可重新启动模式下复制网络文件。
  /B           复制符号链接本身与链接目标。
  /J           复制时不使用缓冲的 I/O。推荐复制大文件时使用。
开关 /Y 可以预先在 COPYCMD 环境变量中设置。
这可能被命令行上的 /-Y 覆盖。

xcopy实例

只复制更新过的文件

在备份的时候，源目录中有些文件更新过，有些文件没更新过。我们只需要复制更新过的文件即可，没必要一股脑复制(覆盖)。
例如：

1

xcopy E:\Blog\blog5\source\_posts E:\Blog\blog5MD /e /Y /d

就是把E:\Blog\blog5\source\_posts这个下的子目录树，复制到E:\Blog\blog5M中，
参数描述：
/e 参数表示，复制E:\Blog\blog5\source\_posts下面的目录和子目录，包括空目录
/y 参数表示，如果目标目录下有同名文件了，不询问，就直接覆盖。
/d对应同名文件，只复制那些源文件时间比目标文件时间新的那些文件。这样可以节省复制的操作。就不会全部一股脑的复制(覆盖)。

复制隐藏文件

如只是单纯地复制一个目录内的所有文件到另一个目录中上，就输入 xcopy 源目录 目的目录 /s /h，如果复制到一半你发现不对劲，可以按键盘热键“Ctrl “ +”Pause /break” 二个热键 来中断复制。

• /s 表示复制目录或子目录
• /h 表示复制隐藏文件，系统文件

例如xcopy E:\Blog\blog5\source\_posts\java* E:\Blog\blog5Test /s /h

从中断处继续复制

如果想把E:\ 盘上所有文件复制到D:\盘上，分为今天复制一点，明天再接着复制一些，后天再接着复制一些。或者是某种原因上次没有复制完成，今天想接着复制。（这种情况是经常在复制文件中出现的）那可怎么办才好呢？
那就输入 xcopy 源目录 目标目录 /s /h /d /y就行啦。他能查出那些文件是已经复制过去啦，那些文件还没有复制过去的。

• /s 复制目录和子目录，不复制空目录
• /h 复制隐藏文件以及系统文件
• /d 这没有提供时间，所以只复制那些源文件时间比目标文件时间新的那些文件。
• /y 直接覆盖，不询问。

参考资料

https://www.cnblogs.com/KevinJasmine/p/4159234.html
cmd copy命令 文件复制
xcopy 实现批处理拷贝文件或文件夹

文档注释写法

文档注释:/**...*/则是为支持jdk 工具javadoc.exe而特有的注释语句。javadoc 工具能从java 源文件中读取第三种注释， 并能识别注释中用@标识的一些特殊变量,制作成HTML 格式的类说明文档。javadoc不但能对一个 java 源文件生成注释文档，而且能对目录和包生成交叉链接的 html 格式的类说明文档
@author 作者名
@version 版本标识
@parameter 参数名及其意义 @since 最早出现的JDK 版本
@return 返回值
@throws 异常类及抛出条件
@deprecated 引起不推荐使用的警告
@see 交叉参考

api文档生成

javadoc作用命令处理范文

javadoc工具默认只处理以public或 protected修饰的

1. 类、
2. 接口、
3. 方法、
4. 成员变量、
5. 构造器，
6. 内部类之前的文档注释。

其他地方，如方法中,构造函数中,……的文档注释,javadoc工具不会处理。

提取private的内容

如果开发者确实希望 javadoc工具可以提取 private修饰的内容,则可以在使用 javadoc工具时增加 -private选项

javadoc命令格式

javadoc命令的基本用法如下:

1

javadoc 选项 Java源文件|包

javadoc的常用选项有如下几个。

• -d :该选项指定一个路径,用于将生成的API文档放到指定目录下,如果不指定则放在当前目录下
• -windowtitle :该选项指定一个字符串,用于设置API文档的浏览器窗口标题。
• -doctite :该选项指定一个HTML格式的文本,用于指定概述页面的标题。
• -header :该选项指定一个HTML格式的文本,包含每个页面的页眉。

除此之外, javadoc命令还包含了大量其他选项,读者可以通过在命令行窗口执行 javadoc-help来查看 javadoc命令的所有选项。
javadoc命令可对源文件、包生成API文档,在上面的语法格式中,Java源文件可以支持通配符,例如,使用*.java来代表当前路径下所有的Java源文件。

实例

JavadocTagTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package myjavadoc.test;
/**
 * Description:
 * 这是当前类的简介
 * @author Silly blue
 * @version 1.0
 */
public class JavadocTagTest
{
        /**
         * 一个得到打招呼字符串的方法。
         * @param name 该参数指定向谁打招呼。
         * @return 返回打招呼的字符串。
         */
        public String hello(String name)
        {
                return name + "，你好！";
        }
}

Test.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package my.test;

/**
 * Description:
 * 这是一个测试类.
 * 哈哈哈哈哈哈.
 */
public class Test
{
    /**
     * 简单测试成员变量
     */
    public int age;
    /**
     * Test类的测试构造器
     */
    public Test()
    {
    }
}

测试:

1

javadoc -d C:\Users\lan\Desktop\TestJavaDoc -windowtitle 测试windowtitle -doctitle 测试doctile -header 测试header Test.java Javad JavadocTest.java

到路径C:\Users\lan\Desktop\TestJavaDoc下，可以看到有一堆html,css,js等文件：

浏览器打开index.html,这个是我们生成的api的入口,各个选项对应的位置:

不指定-windowtitle，-doctitle，-header的效果如下:

1

javadoc -d C:\Users\lan\Desktop\TestJavaDoc Test.java JavadocTagTest.java

显示效果:

javadoc标记

标记的使用是有位置限制的
可以出现在类或者接口文档注释中的有@see、@deprecated、 @author、 @version等;

序号	英文	读音
1	deprecated
2	author

javadoc标记

@see的运用

see的句法有三种：

参考链接

Javadoc 使用详解

前言

Java语言没有提供goto语句来控制程序的跳转,这种做法提高了程序流程控制的可读性,但降低了程序流程控制的灵活性。为了弥补这种不足,Java提供了break和 continue来控制循环结构。除此之外, return可以结束整个方法,当然也就结束了一次循环

使用 break结束循环

结束本层循环

某些时候需要在某种条件出现时强行终止循环,而不是等到循环条件为 false时才退出循环。此时,可以使用 break来完成这个功能。 break用于完全结束一个循环,跳出循环体。不管是哪种循环,一旦在循环体中遇到 break,系统将完全结東该循环,开始执行循环之后的代码。例如如下程序。

1
2
3
4
5
6
7
8
9
10

// 一个简单的for循环
for (int i = 0; i < 10 ; i++ )
{
    System.out.println("i的值是" + i);
    if (i == 2)
    {
        // 执行该语句时将结束循环
        break;
    }
}

运行结果：

1
2
3

i的值是0
i的值是1
i的值是2

运行上面程序,将看到i循环到2时即结束,当i等于2时,循环体内遇到 break语句,程序跳出该循环。

break 标签 结束标签指定的外层循环

break语句不仅可以结束其所在的循环,还可以直接结束其外层循环。此时需要在 break后紧跟一个标签,这个标签用于标识一个外层循环，Java中的标签就是一个紧跟着英文冒号(:)的标识符。与其他语言不同的是,Java中的标签只有放在循环语句之前才有作用。例如下面代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 外层循环，outer作为标识符
outer:
for (int i = 0 ; i < 5 ; i++ )
{
    // 内层循环
    for (int j = 0; j < 3 ; j++ )
    {
        System.out.println("i的值为:" + i + "  j的值为:" + j);
        if (j == 1)
        {
            // 跳出outer标签所标识的循环。
            break outer;
        }
    }
}

运行结果：

1
2

i的值为:0  j的值为:0
i的值为:0  j的值为:1

程序从外层循环进入内层循环后,当j等于1时,程序遇到一个 break outer;语句,这行代码将会结束 outer标签指定的外层循环,而不是结束 break所在的循环。所以看到上面的运行结果。

值得指出的是, break后的标签必须是一个**有效的标签,即这个标签必须在 break语句所在的循环之前定义,或者在其所在循环的外层循环之前定义**。当然,如果把这个标签放在 break语句所在的循环之前,虽然在语法上是没有错的,但是break默认就是结束其所在的循环,多加一个标签来结束本层循环显然画蛇添足。

使用 continue忽略本次循环剩下语句

continue的功能和 break有点类似,区别是 continue只是忽略本次循环剩下语句,接着开始下一次循环,并不会终止循环;而 break则是完全终止循环本身。如下程序示范了 continue的用法。

1
2
3
4
5
6
7
8
9
10
11

// 一个简单的for循环
for (int i = 0; i < 3 ; i++ )
{
    System.out.println("i的值是" + i);
    if (i == 1)
    {
        // 忽略本次循环的剩下语句
        continue;
    }
    System.out.println("continue后的输出语句");
}

运行结果：

1
2
3
4
5

i的值是0
continue后的输出语句
i的值是1
i的值是2
continue后的输出语句

从上面运行结果来看,当i等于1时,程序没有输出“ continue后的输出语句”字符串,因为程序执行到 continue时,忽略了当次循环中 continue语句后的代码。

continue不要放在循环体最后面

从这个意义上来看,如果把一个 continue语句放在单次循环的最后一行,这个 continue语句是没有任何意义的—因为它仅仅忽略了一片空白,没有忽略任何程序语句。

continue标签 结束本次外层循环

与 break类似的是, continue后也可以紧跟一个标签,用于直接跳过标签所标识循环的当次循环的剩下语句,重新开始下一次循环。例如下面代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 外层循环
outer:
for (int i = 0 ; i < 5 ; i++ )
{
    // 内层循环
    for (int j = 0; j < 5 ; j++ )
    {
        System.out.println("i的值为:" + i + "  j的值为:" + j);
        if (j == 1)
        {
            // 忽略outer标签所指定的循环中本次循环所剩下语句。
            continue outer;
        }
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
10

i的值为:0  j的值为:0
i的值为:0  j的值为:1
i的值为:1  j的值为:0
i的值为:1  j的值为:1
i的值为:2  j的值为:0
i的值为:2  j的值为:1
i的值为:3  j的值为:0
i的值为:3  j的值为:1
i的值为:4  j的值为:0
i的值为:4  j的值为:1

可以看到,循环变量j的值将无法超过1,因为每当j等于1时, continue outer;语句就结束了本次外层循环,内层循环没有机会执行完成，直接开始下一次外层循环。与 break类似的是, continue后的标签也必须是一个有效标签,即这个标签通常应该定义在 continue所在循环的外层循环之前。

使用 return结束方法

return关键字并不是专门用于结束循环的, return的功能是结束一个方法。当一个方法执行到一个return语句时( return关键字后还可以跟变量、常量和表达式,这将在方法介绍中有更详细的解释),这个方法将被结束。
Java程序中大部分循环都被放在方法中执行,例如前面介绍的所有循环示范程序。一旦在循环体内执行到一个 return语句, return语句就会结束该方法,循环自然也随之结束。例如下面程序

1
2
3
4
5
6
7
8
9
10

// 一个简单的for循环
for (int i = 0; i < 3 ; i++ )
{
    System.out.println("i的值是" + i);
    if (i == 1)
    {
        return;
    }
    System.out.println("return后的输出语句");
}

运行结果：

1
2
3

i的值是0
return后的输出语句
i的值是1

运行上面程序,循环只能执行到i等于1时,当i等于1时程序将完全结束(当main方法结束时,也就是Java程序结束时)。从这个运行结果来看,虽然 return并不是专门用于循环结构控制的关键字,但通过 return语句确实可以结束一个循环。与 continue和 break不同的是, return直接结束整个方法,不管这个 return处于多少层循环之内。

基本数据类型

$$
\begin{aligned}
\text{基本数据类型}
\begin{cases}
\text{整数类型}
\begin{cases}
byte &1个字节 \\
short &2个字节 \\
int &4个字节 \\
long &8个字节
\end{cases} \\
\text{浮点类型}
\begin{cases}
float &4个字节 \\
double &8个字节
\end{cases} \\
\text{字符类型}
\begin{cases}
char &2个字节
\end{cases} \\
\text{布尔类型}\text{ }boolean
\end{cases}
\end{aligned}
$$

Java只包含这8种基本数据类型,值得指出的是,字符串String不是基本数据类型,字符串是一个类,也就是个引用数据类型。

整型

整型的数值范围

整型的数值范围为:
$$
(-2^{\text{占比特位数}-1}=-2^{\text{占比特位数}\times 8-1})\sim (2^{\text{占比特位数}-1}-1=2^{\text{占比特位数}\times 8-1}-1)
$$

例如

• 一个byte类型整数在内存里占$8$位,可以表示的数值范围为:
  • $(-2^{1\times 8 -1}=-2^7=\textcolor{red}{128})\sim (2^{1\times 8 -1}-1=2^7-1=\textcolor{red}{127})$
• 一个short类型整数在内存里占$16$位,可以表示的数值范围:
  • $-32768(-2^{15})\sim 32767(2^{15}-1)$
• 一个int类型整数在内存里占$32$位,可以表示的数值范围为:
  • $-2147483648(-2^{31})\sim 2147483647(2^{31}-1)$
• 一个long类型整数在内存里占$64$位,表数范围是:
  • $(2^{63})\sim (2^{63}-1)$

直接给出的整数值默认为int类型

int是最常用的整数类型,因此在通常情况下,直接给出一个整数值默认就是int类型。除此之外,有如下两种情形必须指出:

• 如果直接将一个较小的整数值(在byte或 short类型的表数范围内)赋给一个byte或 short变量,系统会自动把这个整数值当成byte或者shot类型来处理。也就是 byte a=1,这里的整数1会直接当成byte类型来处理，short x=3,这里的整数3也会直接当成short类型来处理。
• 如果使用一个巨大的整数值(超出了int类型的表数范围)时,Java不会自动把这个整数值当成long类型来处理。如果希望系统把一个整数值当成long类型来处理,应在这个整数值后增加l或者L作为后缀。通常推荐使用大写的L,因为英文小写l很容易跟数字1搞混。也就是long a=2147483648;这样写，$(2^{31}-1+1=2147483648)$ 虽然在Long的表示范围之内，但是编译器还是认为它是一个int类型，2147483648超出了int的表示范围。所以在编译时会报错，正确的写法为long a=2147483648L;

可以把一个较小的整数值(在int类型的表数范围以内)直接赋给一个long类型的变量,这并不是因为Java会把这个较小的整数值当成long类型来处理,Java依然把这个整数值当成int类型来处理,只是因为int类型的值会自动类型转换到long类型。

数值的表示方式

Java中整数值有4种表示方式:十进制、二进制、八进制和十六进制,其中二进制的整数以0b或0B开头;八进制的整数以0开头;十六进制的整数以0x或者0X开头,其中10-15分别以a-f(此处的af不区分大小写)来表示。下面的代码片段分别使用八进制和十六进制的数。

自动类型转换

我们经常使用 String 类来定义一个字符串。字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

父类

1

java.lang.Object

实现的接口

1

Serializable, CharSequence, Comparable<String>

字段:使用该字段可以对String进行排序

1

static Comparator<String> CASE_INSENSITIVE_ORDER一个对 String 对象进行排序的 Comparator，作用与 compareToIgnoreCase 相同 

实例

1
2
3
4
5
6
7
8

public static void main(String[] args)
{
    String[] rawStrings ={"B", "com.lan", "b", "A", "a", "c", "C"};
    System.out.println(Arrays.toString(rawStrings));
    // 使用String.CASE_INSENSITIVE_ORDER进行排序
    Arrays.sort(rawStrings, String.CASE_INSENSITIVE_ORDER);
    System.out.println(Arrays.toString(rawStrings));
}

运行结果：

1

[B, com.lan, b, A, a, c, C][A, a, B, b, c, C, com.lan]

现在只知道可以进行排序，具体后面再研究，先接着写下去。好像可以参考的博客：http://blog.51cto.com/lavasoft/68380
4.构造方法：
(1)默认构造方法：

1

String()初始化一个新创建的 String 对象，使其表示一个空字符序列。 

(2)使用整个byte数组创建String对象且使用默认字符集：

1

String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。String(byte[] bytes, int offset, int length)通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。

(3)使用整个byte数组创建String对象且指定字符集

1

String(byte[] bytes, String charsetName)通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。String(byte[] bytes, Charset charset)通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 

(4)使用byte数组的一部分创建String对象且指定字符集，指定在byte数组中的起始下标和长度:

1

String(byte[] bytes, int offset, int length, Charset charset)通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。String(byte[] bytes, int offset, int length, String charsetName)通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。 

(5)使用字符数组(char[])创建String对象：

1

String(char[] value)分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。String(char[] value, int offset, int count)分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 

(6)使用Unicode代码点数组创建String对象：

1

String(int[] codePoints, int offset, int count)分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。 

(7)使用变长字符串StringBuffer,StringBuilder做为参数创建String对象：

1

String(StringBuffer buffer)分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。String(StringBuilder builder)分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。 

(8)使用String对象作为参数创建String对象,相当于创建一个旧的String对象的副本

1

String(String original)初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 

5. 方法
(1)字符串的长度，判断字符串是否为空字符串。

1

boolean isEmpty()当且仅当 length() 为 0 时返回 true。int length()返回此字符串的长度。 

(2)判断该字符串中是否包含指定的字符串，获取字符

1

boolean contains(CharSequence s)当且仅当此字符串包含指定的 char 值序列时，返回 true。

(3)返回指定索引处的字符值：

1

char charAt(int index)返回指定索引处的 char 值。

(4)字符串连接：

1

String concat(String str)将指定字符串连接到此字符串的结尾。 

(5)从前向后扫描，返回字符或者字符串参数在该字符串中第一次出现的索引：

1

int indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引。int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。int indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 

(6)从后向前扫描，返回字符或字符串参数在该字符串中第一次出现的索引：

1

int lastIndexOf(int ch)返回指定字符在此字符串中最后一次出现处的索引。int lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。int lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。int lastIndexOf(String str, int fromIndex)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 

(7)获取该字符串的一部分子字符串：

1

tring substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个子字符串。

这个方法经常与上面两个方法String.lastIndexOf()和String.indexOf()方法一起使用，使用这两个方法查找分割的位置，然后再使用String.subString()方法进行分割。
(8)获取该字符串的一部分，以字符序列返回：

1

CharSequence subSequence(int beginIndex, int endIndex)返回一个新的字符序列，它是此序列的一个子序列。 

(9)重写Object的方法：

1

boolean equals(Object anObject)将此字符串与指定的对象比较。int hashCode()返回此字符串的哈希码。String toString()返回此对象本身（它已经是一个字符串！）。

(10)实现comparable接口的比较方法：

1

int compareTo(String anotherString)按字典顺序比较两个字符串。 

(11)不按大小写的比较方法

1

int compareToIgnoreCase(String str)按字典顺序比较两个字符串，不考虑大小写。boolean equalsIgnoreCase(String anotherString)将此 String 与另一个 String 比较，不考虑大小写。 

(12)基本类型：int,long,float,double,char,char数组，Object(对象)转换成String的方法:String.valueOf(xxx)

1

static String valueOf(int i)返回 int 参数的字符串表示形式。static String valueOf(long l)返回 long 参数的字符串表示形式。static String valueOf(float f)返回 float 参数的字符串表示形式。static String valueOf(double d)返回 double 参数的字符串表示形式。static String valueOf(boolean b)返回 boolean 参数的字符串表示形式。static String valueOf(char c)返回 char 参数的字符串表示形式。static String valueOf(char[] data)返回 char 数组参数的字符串表示形式。static String valueOf(char[] data, int offset, int count)返回 char 数组参数的特定子数组的字符串表示形式。static String valueOf(Object obj)返回 Object 参数的字符串表示形式。 

String字符串转为字节数组

大小写转换

正则匹配

正则表达式分割

注意，获取的数组中不包含作为分割符的字符(或字符串)
(17)判断字符串的前缀后缀：

1

boolean startsWith(String prefix)测试此字符串是否以指定的前缀开始。boolean startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始。boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束。 

(18)该字符串与指定的字符序列或者StringBuffer比较

1

boolean contentEquals(CharSequence cs)将此字符串与指定的 CharSequence 比较。boolean contentEquals(StringBuffer sb)将此字符串与指定的 StringBuffer 比较。 

(19)把字符数组转换成String

1
2
3
4

static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String。
static String copyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String。 

(20)把该字符串中的字符拷贝到指定的字符数组中去：

1
2

 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组。

(21)把该字符串转换成字符数组：

1

char[] toCharArray()将此字符串转换为一个新的字符数组。

(22)使用新字符替换字符串中的旧字符：

1
2
3
4

 String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)
使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 

(23)使用新子字符串替换该字符串中匹配正则表达式的那些旧子字符串：一个全部替换，一个只替换第一个：

1
2
3
4

 String replaceAll(String regex, String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement)
使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

**(24)把该字符串规范化表示，去掉该字符串的前后空白符： **

1
2
3
4

 String intern()
返回字符串对象的规范化表示形式。
String trim()
返回字符串的副本，忽略前导空白和尾部空白。 

** (25)Unicode代码点相关：**

1
2
3
4
5
6
7
8

 int codePointAt(int index)
返回指定索引处的字符（Unicode 代码点）。
int codePointBefore(int index)
返回指定索引之前的字符（Unicode 代码点）。
int codePointCount(int beginIndex, int endIndex)
返回此 String 的指定文本范围中的 Unicode 代码点数。
int offsetByCodePoints(int index, int codePointOffset)
返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。 

(26)格式化字符串：

1
2
3
4

static String format(Locale l, String format, Object... args)
使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
static String format(String format, Object... args)
使用指定的格式字符串和参数返回一个格式化字符串。

(27)判断该字符串的子字符串是否相等：

1
2
3
4

 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。 

Pattern类

Pattern在java.util.regex包中，是正则表达式的编译表示形式，此类的实例是不可变的，可供多个并发线程安全使用。

组和捕获

捕获组可以通过从左到右计算**其开括号(**来编号。

在表达式 ((A)(B(C))) 中，存在四个组：

组零始终代表整个表达式。

Pattern.compile方法 创建Pattern对象

Pattern类构造器是私有的，不能通过new创建Pattern对象。Pattern调用静态方法compile返回Pattern实例。

Pattern.compile(String regex)

1
2
3
4

// 创建模板
String regex = "[a-z]";
// 创建模式
Pattern p=Pattern.compile(regex);

Pattern.compile(String regex, int flags)

匹配标志flags

第二个compile方法的flags可以传入如下值

嵌入式标志表达式

嵌入式标志表达式是 compile 的双参数版本的替代，并且在正则表达式本身中指定。
与 Pattern 的可公开访问的字段对应的嵌入式标志表达式如下表所示：

不区分大小写的Pattern Pattern.CASE_INSENSITIVE

可以在compile方法中传入Pattern.CASE_INSENSITIVE来创建不区分大小写的模板

1
2

// 创建模板，不区分大小写
Pattern p2=Pattern.compile(regex,Pattern.CASE_INSENSITIVE);

也可以通过嵌入式标志表达式(?i)启用不区分大小写的匹配。

1
2
3
4
5
6

String upCase = "HELLOWORLD";
// 方式1，创建模板，不区分大小写
Pattern p2 = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE);
System.out.println(p2.matcher(upCase).matches());//true
// 方式2，使用嵌入式标志表达式(?i)
System.out.println(Pattern.matches("(?i)[a-z]+", upCase));//true

启用多行模式Pattern Pattern.MULTILINE

默认情况下，表达式^和$仅在整个输入序列的开头和结尾匹配。
在多行模式下，表达式^和$分别在行终止符或输入序列的结尾之后或之前匹配。

也可以通过嵌入式标志表达式(?m)启用多行模式。

1
2

// 创建模板，不区分大小写
Pattern p3=Pattern.compile(regex,Pattern.CASE_INSENSITIVE);

编译带有多个标志的模式

要编译带有多个标志的模式，请使用按位或运算符 “|” 分隔要包含的标志。

1

pattern = Pattern.compile("[az]$", Pattern.MULTILINE | Pattern.UNIX_LINES);

也可以先把多个模式保存在int变量中，然后在compile方法中传入该int变量：

1
2

final int flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;
Pattern pattern = Pattern.compile("aa", flags);

flags方法 返回匹配标志

1
2
3
4
5

// 创建模板，启用多行模式
Pattern p3 = Pattern.compile("^\\w+$", Pattern.MULTILINE);
if (p3.flags() == Pattern.MULTILINE) {
    System.out.println("多行模式");//true
}

matcher方法 创建Matcher类

此方法返回一个Matcher对象。Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例。
Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持。

pattern方法toString方法返回正则表达式字符串

1
2
3

Pattern p3 = Pattern.compile("^\\w+$", Pattern.MULTILINE);
System.out.println(p3.toString());//^\w+$
System.out.println(p3.pattern());//^\w+$

这两个方法的返回值都是一样的，查看源码可以看到这两个方法的代码也是一样的

1
2
3
4
5
6
7
8
9

// ......
public String pattern() {
    return pattern;
}
// ......
public String toString() {
    return pattern;
}
// ......

quote(str)生产正则表达式字面量

返回指定 String 的文字模式 String。此方法生成 String，可用于创建与 String s 匹配的 Pattern，就像它是文字模式一样。输入序列中的元字符或转义序列将没有特殊含义。

Java中Pattern类的quote方法将任何字符串（包括正则表达式）都转换成字符串常量，不具有任何匹配功能。

Returns a literal pattern String for the specified String.
This method produces a String that can be used to create a Pattern that would match the string s as if it were a literal pattern.
Metacharacters or escape sequences in the input sequence will be given no special meaning.(使给定的正则表达式没有任何的特殊意义)
Parameters:
s - The string to be literalized
Returns:
A literal string replacement

参考资料：
https://www.cnblogs.com/theRhyme/p/10310709.html
https://stackoverflow.com/questions/15409296/what-is-the-use-of-pattern-quote-method
https://blog.csdn.net/yin380697242/article/details/52050023

1
2
3
4
5
6
7
8
9
10
11

String str = ".*";
//获取该字符串对应的字面量
String literalStr=Pattern.quote(str);
//输出字面量
System.out.println("literalStr = " + literalStr);
//使用正则表达式  进行匹配
System.out.println(Pattern.matches(str, "HelloWorld"));
//使用 正则表达式的字面量 进行匹配
System.out.println(Pattern.matches(literalStr, "HelloWorld"));
//字面量匹配原来的字符串
System.out.println(Pattern.matches(literalStr, str));

matches 直接匹配整个字符序列

此方法是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串的情况.

1

Pattern.matcher(String regex,CharSequence input)

它与下面这段代码等价：

1

Pattern.compile(regex).matcher(input).matches()

示例代码：

1
2

String str="hello";
System.out.println(Pattern.matches("^hello$", str));// true

split 分割字符序列

split方法是一个很好的工具，用于收集位于匹配模式两侧的文本。

split(CharSequence, int)

参考资料：http://www.51gjie.com/java/772.html
方法split(CharSequence input, int limit)中的limit表示要分割成多少段，

• 如果limit>0，则分割成limit-1段。

  • 如果limit-1大于可以最终可以分割的段数，则分割到不能分割就停止。

• 如果limit<=0，则尽可能的分割，直到无法分割为止。

• input 要拆分的字符序列

• limit 结果阈值

• return 根据围绕此模式的匹配来拆分输入后所计算的字符串数组

limit参数控制应用模式的次数，从而影响结果数组的长度。

1. 如果 limit >0，那么模式至多应用 limit- 1 次，数组的长度不大于limit，并且数组的最后条目将包含除最后的匹配定界符之外的所有输入。
2. 如果 limit <=0，那么将应用模式的次数不受限制，并且数组可以为任意长度。
3. 如果 limit ==0，那么应用模式的次数不受限制，数组可以为任意长度，并且将丢弃尾部空字符串。

此方法返回的数组包含输入序列的子字符串，由匹配此模式的另一子序列或输入序列的结尾终止。数组中子字符串的顺序与其在输入中出现的顺序相同。
如果此模式与输入的任何子序列都不匹配，那么得到的数组仅包含一个元素，即字符串形式的输入序列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

private static void testSplit2() {
    String str=" 1_Hello 2_World 3_Welcome 4_To 5_Learn 6_Java ";
    Pattern p=Pattern.compile(" ");
    // 分割成1段，等于不分割
    testSplitLimit(str, p,1);
    // 分割成3段，切两刀
    testSplitLimit(str, p,3);
    // 分成10段，实际上无法分割成10段
    testSplitLimit(str, p,10);
    // 分割成-10段，表示全部分割，保留最后的空字符串
    testSplitLimit(str, p,-10);
    // 分割成0段，表示全部分割，并且不保留最后的空字符串。
    testSplitLimit(str, p,0);
}

private static void testSplitLimit(String str, Pattern p, int limit) {
    // 分割成limit段，或者说应用模式limit-1次
    String[] strs= p.split(str, limit);
    for (int i = 0; i < strs.length; i++) {
        System.out.println("strs["+i+"]=" + strs[i]);
    }
    System.out.println("====================");
}

运行结果：

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

strs[0]= 1_Hello 2_World 3_Welcome 4_To 5_Learn 6_Java 
====================
strs[0]=
strs[1]=1_Hello
strs[2]=2_World 3_Welcome 4_To 5_Learn 6_Java 
====================
strs[0]=
strs[1]=1_Hello
strs[2]=2_World
strs[3]=3_Welcome
strs[4]=4_To
strs[5]=5_Learn
strs[6]=6_Java
strs[7]=
====================
strs[0]=
strs[1]=1_Hello
strs[2]=2_World
strs[3]=3_Welcome
strs[4]=4_To
strs[5]=5_Learn
strs[6]=6_Java
strs[7]=
====================
strs[0]=
strs[1]=1_Hello
strs[2]=2_World
strs[3]=3_Welcome
strs[4]=4_To
strs[5]=5_Learn
strs[6]=6_Java
====================

split(CharSequence)

等于上面的split(CharSequence, 0)，因此，得到的数组中不包括尾部空字符串。

1
2
3
4
5
6

String str="_Welcome_To_Learn_Java_";
Pattern p=Pattern.compile("_");
String[] strs=p.split(str);
for (int i = 0; i < strs.length; i++) {
    System.out.println("strs["+i+"]=" + strs[i]);
}

运行结果：

1
2
3
4
5

strs[0]=
strs[1]=Welcome
strs[2]=To
strs[3]=Learn
strs[4]=Java

split小结

• 如果分隔符(模式)在字符串的头部和尾部都出现，分割得到的数组的第一个和最后一个元素为空字符串。
  • 如果是split(str)方法的话，不会把最后一个空字符串保存到数组中，但第一个空字符会保留。

java8新特性

java11新特性

参考资料

https://pingfangx.github.io/java-tutorials/essential/regex/pattern.html
http://www.51gjie.com/java/758.html
http://www.51gjie.com/java/772.html

问题描述

平时想要在项目目录中输入git命令，我需要先打开git-bash窗口，然后还要cd到项目目录中。这挺麻烦的。我现在想:
通过批处理脚本,直接在某个目录中启动git-bash窗口。

实现

在项目目录下,创建一个批处理脚本(StartGitBash.bat)文件,写入如下的命令:

1

start F:\Program" "Files\Git\git-bash.exe --cd=D:\dev\workspace\HexoTools

命令解释

• start用于启动一个窗口
• F:\Program" "Files\Git\git-bash.exe是git-bash的路径，注意路径中间的空格要用引号包起来
• --cd=D:\dev\workspace\HexoTools指定git-bash的启动目录为D:\dev\workspace\HexoTools,

点击批处理在项目目录下打开git-bash

现在我只要点击项目目录下的StartGitBash.bat:

就可在项目目录下打开git-bash了：

参考资料

如何使用脚本启动具有特定工作目录的Git Bash窗口？

安装JavaFX插件e(fx)clipse

依次点击Help–Eclipse Marketplace...进入eclipse应用市场，

输入e(fx)clipse,按下回车，安装匹配的插件:

然后等待安装完毕，安装完毕后重启eclipse,打开首选项，如果看到JavaFX则说明安装成功:

下载 scene builder

https://www.oracle.com/technetwork/java/javase/downloads/javafxscenebuilder-1x-archive-2199384.html

安装

点击安装即可

eclipse中指定scene builder路径

参考资料

在Eclipse安装JavaFX Scene Builder