[root@localhost~]#shutdown [选项] 时间
选项：
-c：取消前一个关机命令
-h：关机
-r：重启
[root@localhost~]#halt
[root@localhost~]#poweroff
[root@localhost~]#init 0
[root@localhost~]# reboot
[root@localhost~]# init 6
0 关机
1 单用户
2 不完全多用户，不含NFS服务
3 完全多用户
4 未分配
5 图形界面
6 重启
[root@localhost~]# cat/etc/inittab
Id:3:initdefault:
[root@localhost~]# runlevel
[root@localhost~]# logout
为了保存数目不确定的对象，JDK中提供了一系列特殊的类，这写类可以存储任意类型的对象，并且长度可变，统称为集合。这些类都位于util包中，使用的时候一定要注意导包的问题，否则会出现异常。
集合按照其存储结构可以分为两大类，即单列集合（Collection）和双列集合（Map）。体系结构（常用的类和接口）：
Collection:单列集合类的跟接口，用于存储一系列符合某种规则的元素。
|--List:Collection的子接口，特点是元素有序，元素可重复。
|--ArrayList：List的接口的一个实现类，ArrayList内部封装了一个长度可变的数组对象，当存入的元素超过数组长度时，ArrayList会在内部中分配一个更大的数组来存储这些元素，因此可将ArrayList集合看做一个长度可变的数组。查询效率较高。
|--LinkedList：List集合的一个实现类，该集合内部维护了一个双向循环列表，链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素，从而可以将所有的元素彼此连接起来。增删效率较高。
|--Set:Collection的子接口，特点是元素无序，并且不可重复。
|--HashSet：Set接口的实现类，HashSet底层实际上是一个HashMap，HashSet其实是HashMap中的Key的部分。
|--TreeSet：Set接口的实现类，内部采用自平衡的排序二叉树来存储元素，这样结构可以保证TreeSet集合中没有重复的元素，并且可以对元素进行排序。
Map:双列集合类的根接口，用于存储键（Key）、值（Value）映射关系的元素，每个元素都包含一对键值。
|--HashMap：Map的实现类，它用于存储键值映射关系，但必须保证不出现重复的键，键相同，值覆盖。
|--TreeMap:Map的实现类，它也用于存储键值映射关系，但必须保证不出现重复的键。在TreeMap中是通过二叉树的原理保证键的唯一性，这与TreeSet集合的存储原理一样，因此TreeMap中所有的键是按照某顺序排列的。
注：元素有序是指存入数据的数据和取出数据的顺序是一致的。
自定义异常
在实际开发中，因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象，所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题，进行自定义的异常封装。自定义异常类必须继承自Exception或其子类。
在实际开发中，如果没有特殊的要求，自定义异常类只需要继承Exception类，在构造方法中使用super（）语句，调用Exception的构造方法即可。自定义异常时，如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。
自定义了异常后，需要用到throw关键字，throw关键字用于在方法中声明抛出异常的实例对象，其语法格式如下：
throw Exception 异常对象
定义类继承Exception或者RuntimeException
为了让该自定义类具备可抛性。
让该类具备操作异常的共性方法。
当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。
继承Exception原因
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别
throws使用在函数上。throw使用在函数内。
throws后面跟的异常类。可以跟多个，用逗号隔开。throw后跟的是异常对象。
注：当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
异常在子父类覆盖中的体现
1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
2.如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理,绝对不能抛。
try……catch和finally
java中，由于发生了异常，程序立即终止，无法继续向下执行。为了解决这样的问题，java中提供了一种对异常进行处理的方式————异常捕获。异常捕获通常使用try……catch语句。
语法：
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}注：
try代码块中编写可能发生异常的java语句，catch代码块中编写针对异常进行处理的代码。当try代码块中的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，并将这个对象传递给catch代码块。catch代码块需要一个参数指明它所能够接收的异常类型，这个参数的类型必须是Exception类或其子类。
在try代码块中，发生异常语句后面的代码块是不会被执行的。
建立在进行catch处理时，catch中一定要定义具体处理方式。
finally中的语句是一定会执行的，通常用于关闭资源。除了在try……catch中执行了System.exit(0)语句。System.exit(0)表示退出当前的java虚拟机，java虚拟机停止了，任何代码都不能再执行了。
catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。
throws关键字
java中允许在方法的后面使用throws关键字对外声明该方法有可能发生异常，这样调用者在调用方法时就明确知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。
语法：
修饰符 返回值类型 方法名（[参数1，参数2……]） throws ExceptionType1[,ExceptionType2……]{}
注：
使用throws处理异常并不是真正的处理异常，而是推卸责任，谁调用就会抛给谁。
便于提高安全性，让调用出进行处理。不处理编译失败。
对多异常的处理
1.声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2.对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。catch必须从上到下，从小到大捕捉。
java中的异常都是类，在异常对象中会携带一些信息给我们，我们通过这个异常对象将信息提取出来
异常体系
Throwable
|--Error
|--IOError
|--AWTError
|--其他子类
|--Exception
|--RuntimeException
|--ArithmeticException
|--ClassCastException
|--其他子类
|--其他子类
Throwable
|--Error
|--IOError
|--AWTError
|--其他子类
|--Exception
|--RuntimeException
|--ArithmeticException
|--ClassCastException
|--其他子类
|--其他子类异常体系的特点
1.异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。
2.Error是java程序运行过程中出现了错误，错误是不能够处理，只能退出JVM。
3.Exception是可以处理的。如果没有处理异常，则程序直接退出JVM。
4.编译时异常：所有的Exception的直接子类都是“编译时异常”。
异常的分类
编译时异常：编译时被检测异常，该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表这可以被处理。Exception类中除了RuntimeException类及其子类都是编译时异常。
运行时异常(编译时不检测)：在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。RuntimeException类及其子类都是运行时异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
异常的处理原则
处理方式有两种：try 或者 throws。
调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。
多个catch，父类的catch放到最下面。
catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}异常的注意事项
在子父类覆盖时：
子类抛出的异常必须是父类的异常的子类或者子集。
如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
异常的好处
将问题进行封装。
将正常流程代码和问题处理代码相分离，方便于阅读。
Vim是一个类似于Vi的著名的功能强大、高度可定制的文本编辑器，在Vi的基础上改进和增加了很多特性。 VIM是自由软件。
基本上vi可以分为三种状态，分别是命令模式（command mode）、插入模式（Insert mode）和底行模式（last line mode）.
1)命令行模式command mode）
控制屏幕光标的移动，字符、字或行的删除，移动复制某区段及进入Insert mode下，或者到 last line mode。
2) 插入模式（Insert mode）
只有在Insert mode下，才可以做文字输入，按「ESC」键可回到命令行模式。
3) 底行模式（last line mode）
将文件保存或退出vi，也可以设置编辑环境，如寻找字符串、列出行号……等。
不过一般我们在使用时把vi简化成两个模式，就是将底行模式（last line mode）也算入命令行模式（command mode）。
vim 文件名
打开文件或者创建并打开文件
vim + 文件名
光标定位到文件的最后一行
vim +n 文件名
光标定位到第n行
vim +/xxx 文件名
光标定位到第一次出现xxx的位置，按n向下切换
vim aa bb cc
同时创建aa，bb，cc（底行模式下，按:n切换到下一个，:N（:prev）切换到前一个）
底行模式
：w 将文件从内存写入硬盘，也就是文件保存过程
：q 退出vim当前打开的文件
：！强制执行（可以配合使用，退出时一般使用:wq,退出的同时还可以保存文件）
：ls 列出当前编辑器打开的所有文件
：n切换到下一个文件
：N切换到上一个文件
：n光标定位到第n行
：/xxx第一次出现位置
：？xxx从光标位置向前搜索
命令模式下常用命令
-h 光标左移
-j 光标下移
-k 光标上移
-l 光标右移
Ctrl +f 向下翻页
Ctrl+b 向上翻页
Ctrl+d 向下翻半页
Ctrl+u 向上翻半页
dd 删除光标所在的行
o 在光标所在的行的下方插入一行并切换到输入模式
yy 复制光标所在的行
p 在光标所在的行的下方粘贴
P 在光标所在的行的上方粘贴
常用压缩格式：.zip .gz .bz2
常用压缩格式：.tar.gz .tar.bz2
zip 压缩文件名 源文件
zip –r 压缩文件名 源目录
unzip 压缩文件
gzip 源文件
gzip –c 源文件 > 压缩文件
例如： gizp –c qqq > qqq.zip
gzip –r 目录
gzip –d 压缩文件
gunzip 压缩文件
bzip2 源文件
bzip –k 源文件
注意：bzip2命令不能压缩目录
bzip –d 压缩文件
bunzip2 压缩文件
tar –cvf 打包文件名 源文件
选项：
-c：打包
-v：显示过程
-f：指定打包后的文件名例如： tar -cvf qqq.tar qqq
tar –xvf 打包文件名
选项：
-x：解打包例如：tar –xvf qqq.tar
其实.tar.gz格式是先打包为.tar格式，再压缩为.gz格式
tar –zcvf 压缩包名.tar.gz 源文件
选项：
-z：压缩为.tar.gz格式tar –zxvf 压缩包名.tar.gz
选项：
-x：解压缩.tar.gz格式
tar -jcvf 压缩包名.tar.bz2 源文件
选项：
-z：压缩为.tar.bz2格式tar -jxvf 压缩包名.tar.bz2
选项：
-x：解压缩.tar.bz2格式格式：ls [选项] [文件或目录]
选项：
-a显示所有文件，包含隐藏文件
-l显示详细信息
-d查看目录属性
-h人性化显示文件大小
-i显示inode
格式：mkdir –p [目录名]
参数：-p递归创建
格式：cd [目录]
简化操作:
cd~ 进入当前用户的家目录
cd
cd – 进入上次目录
cd .. 进入上一级目录
cd. 进入当前目录
格式：rmdir [目录名]
格式：rm –rf [文件或目录]
选项：
-r删除目录
-f强制
格式：cp [选项] 原文件或目录
选项：
-r 复制目录
-p 连带文件属性复制
-d 若原文件是链接文件，则复制链接属性
-a 相当于-pdr
格式：mv 原文件或目录
格式：whereis 命令名
选项：
-b：只查找可执行文件
-m：只查找帮助文档
格式：which 文件名
格式：shutdown [参数] 时间
参数：
-r：重启
-h：关机
-c：取消前一个关机命令
命令格式
命令 [选项] [参数]
注意：个别命令使用不遵循此格式
当有多个选项时，可以写在一起
简化选项与完整选项 ，比如：-a等于-all由于字符串是常量，因此一旦被创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符串。为了便于对字符串的修改，在JDK中提供了一个StringBuffer类（也称字符串缓冲区）。StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类，类似一个容器，当在其中添加或删除字符时，并不会产生新的StringBuffer对象。
StringNuffer类的特点
长度是可变化的。
可以字节操作多个数据类型。
最终会通过toString方法变成字符串。
StringBuffer类的常用方法
存储
StringBuffer append（char c） 将指定数据作为参数添加到已有数据结尾处
StringBuffer insert(int offset,String str) 将字符串中的offset位置插入字符串str
删除
StringBuffer delete(int start,int end) 删除StringBuffer对象中指定范围的字符或字符串序列（包含start，不包含end）。
Stringbuffer deleteCharAt(int index) 移除次序列指定位置的字符
获取
char charAt(int index) 获取指定位置的字符
int indexOf(String str) 获取指定字符串的位置
int lastIndexOf(String str) 获取指定字符串最后一次出现的位置
int length() 获取字符串的长度
String substring(int start, int end) 获取指定位置的字符串
修改
StringBuffer replace(int start,int end,String s) 在StringBuffer对象中替换指定的字符或字符串序列（包括star不包括end）
void setCharAt(int index,char ch) 修改指定位置index处的字符序列
反转
StringBuffer reverse() 将此字符串序列用其反转形式取代
注意：JDK1.5 版本之后出现了StringBuilder,StringBuffer是线程同步。,StringBuilder是线程不同步,以后开发，建议使用StringBuilder。
代码示例：
public class StringBufferDemo {
public static void main(String [] args) {
sop("添加");
add();
sop("删除");
delete();
sop("获取");
select();
sop("修改");
alert();
}
public static void add() {
StringBuffer sb = new StringBuffer();
sb.append("dddddd");
sop("在末尾处添加:"+sb);
sb.insert(2,"12");
sop("在第二个位置添加12:"+sb);
}
public static void delete() {
StringBuffer sb = new StringBuffer("abcdefghigklmn");
sb.delete(0,2);
sop("删除0到2位置的"+sb);
sb.deleteCharAt(3);
sop("删除第3个位置的字符"+sb);
}
public static void select() {
StringBuffer sb = new StringBuffer("abcdefghigak");
sop("获取下标为2的字符"+sb.charAt(2));
sop("获取字符e的下标"+sb.indexOf("e"));
sop("获取a最后一次出现的下标"+sb.lastIndexOf("a"));
sop("获取字符串的长度"+sb.length());
sop("获取1到3位置的字符串"+sb.substring(1,3));
}
public static void alert() {
StringBuffer sb = new StringBuffer("abcdefghigkl");
sop("修改1到3位置上的字符串为zz:"+sb.replace(1, 3, "zz"));
sb.setCharAt(5,'r');
sop("修改5位置上的字符为r:"+sb);
sop("反转"+sb.reverse());
}
public static void sop(Object obj) {
System.out.println(obj);
}
}在程序中经常会用到字符串，在java中定义了String和StringBuffer两给类来封装字符串，并提供了一系列操纵字符串的方法，它们都位于java.lang包中，因此不需要导包就可以直接使用。String类是不可变类，也就是说String对象声明后，将不可修改（可以理解为字符串一旦创建就不可以修改）。
String的初始化
1.使用字符串常量直接初始化一个String|对象。
String [变量名] = "变量值";
2.使用String的构造方法初始化字符串对象
String() 创建一个内容为空的字符串
String(char[] value) 根据指定的字符数组创建对象。
String(String value) 根据指定的字符串内容创建对象
代码示例：
public class StringDemo1 {
public static void main(String [] args) {
String str1 = "sunxiaoning";//使用字符串常量直接初始化一个String|对象。
String str2 = new String();//创建一个内容为空的字符串
char ch[] = {'s','x','n'};
String str3 = new String(ch);//根据指定的字符数组创建对象。
String str4 = new String("sunxiaoning");//根据指定的字符串内容创建对象
//打印字符串
sop(str1);
sop(str2);
sop(str3);
sop(str4);
}
/*
* 打印函数
* */
public static void sop(Object obj) {
System.out.println(obj);
}
}String的常见操作
1.获取
int length() 返回此字符串的长度
char charAt(int index) 根据位置获取位置上某个字符。
int indexOf(int ch) 返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch, int fromIndex) 从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexOf(String str) 返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex) 从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(int ch) 返回此字符在此字符串中最后一次出现处的索引
代码演示：
public class StringDemo2 {
public static void main(String [] args) {
String str = "aabbccddeeff";
sop("字符串的长度为"+str.length());
sop("下标为5的字符是"+str.charAt(5));
sop("第一次出现c的位置是"+str.indexOf('c'));
sop("从第六个位置数，出现c的位置是"+str.indexOf('d',6));
sop("第一次出现字符串cc的位置是"+str.indexOf("dd"));
sop("最后一次出现cc的位置是"+str.lastIndexOf("cc"));
}
public static void sop(Object obj) {
System.out.println(obj);
}
}2.判断
boolean contains(CharSequence cs) 判断此字符串中是否包含指定的字符序列
boolean isEmpty() 判断字符中是否有内容，原理就是判断长度是否为0，当且仅当字符串长度为0时返回true
boolean startsWith(String prefix) 判断此字符串是否以指定的字符串开始
boolean endsWith(String suffix) 判断此字符串是否以指定的字符串结尾
boolean equals(Object anObject) 将此字符串与指定字符串比较，判断字符串内容是否相同，复写了Object类中的equals方法。
boolean equalsIgnoreCase(String anotherString) 判断内容是否相同，并忽略大小写。
代码示例
public class StringDemo3 {
public static void main(String []args) {
String str1 = "aaaabbbbb";
String str2 = "aabbcc";
String str3 = "aAbbcc";
sop("str1中是否包含aa"+str1.contains("aa"));
sop("Str1的长度为0吗"+str1.isEmpty());
sop("str1是以cc开头吗"+str1.startsWith("cc"));
sop("str1是以bb结尾吗"+str1.endsWith("bb"));
sop("str1的内容与str2相同吗"+str1.equals(str2));
sop("str2的内容与str3相同吗（忽略大小写）"+str2.equalsIgnoreCase(str3));
}
public static void sop(Object obj) {
System.out.println(obj);
}
}注意：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。而且该方法即可以判断，有可以获取出现的位置。
3.转换
将字符数组转成字符串
构造方法
String(char[])
String(char[],offset,count) 将字符数组中的一部分转成字符串。
静态方法
static String copyValueOf(char[])
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[])
将字符串转成字符数组
-char[] toCharArray()
将字节数组转成字符串
String(byte[])
String(byte[],offset,count) 将字节数组中的一部分转成字符串
将字符串转成字节数组
byte[] getBytes()
将基本数据类型转成字符串
static String valueOf(int)
static String valueOf(double)
4.替换
String replace(oldchar,newchar) 将字符串中的oldchar替换成newchar
5.切割
String[] split(String regex) 根据参数regex将原来的字符串分割为若干子串
6.子串。获取字符串中的一部分。
String substring(int beginIndex) 返回一个新字符串，它包含字符串索引beginIndex后的所有字符。
String substring(int beginIndex,int endIndex) 返回一个新字符串，它包含此字符串中索引beginIndex到索引endindex之间的所有字符。
7.将字符串转成大写或则小写
String toUpperCase() 将字符串转成大写
String toLowerCase() 将字符串转成小写
8.将字符串两端的多个空格去除
String trim();
9.对两个字符串进行自然顺序的比较
int compareTo(string);