今天开始学习linux系统管理，好好学习，赚更多的钱！！
一.给我这样的生瓜的一点建议：
   1.尽力去学好vi编辑器（在linux系统中最常见的是它的一种经过重写的形式，vim）
     尽管一开始大家很不习惯，也要克服。
   2.熟练掌握perl和shell语言，因为在linux世界里，他就是你的利器。
     当然Python语言也是一个不错的语言，他可读性好 易于维护 也要学偶。
   3.书上推荐学习一种叫except编程语言，从没听过，说是用于驱动 交互式程序执行的前段语言。
二.linux于unix的关系
   1.linux重写了unix，也丰富了unix，它遵循posix标准，能够在几种硬件平台上运行，兼容现有的大多数       unix软件，说到这里大家可能会认为linux就是unix的一种变体，但说到底不还是unix吗，我也是这么
   认为的，书上说他俩是不同的，在我看来不是很让我信服，可能是我不喜欢遵守法律的原因吧。
  （原文两个理由如下：）
       ---他同大多数的unix变体不同的是，他是自由的，开源的，而且由成百上千的个人和组织无私奉献
           协同开发出来，linux融入了在原来unix版本中没有的技术改进，所以说它超出了克隆unix的范畴，
          （这里我不太明白的是到底unix根本就没办法实现所为的技术改进，还是说现有的版本还没有推出）
       ---从法律上讲，它也是有别于unix的东西，严格来说不能称为unix
          （迷糊！！！！！，外国人到底是真的遵守法律还是为了商业）
    2. 论述完以上linux不是unix的论断后，他后面有来了一句
       ---- 还值得一提的是linux不是现今世界上唯一的自由unix版本
           （我日，是翻译蓝那  还是我的理解有问题 ？？
    3.在一个知道一个名词BSD
        （UC Berkely ）加州大学的伯克利分校的BSD（Berkely Software Distribution)伯克利软件发布
 

    

今天修改一个前人的程序，一段sql文，里面的内容一个很奇怪的地方，


这里面a表中的FromId 是char（8），b表中的toId是char（9） 一开始感觉这能出来数据吗 可真他娘的出来了，晕！！！，公司不让上网，看书找不到介绍，自己慢慢猜测，一定是oracle自动给位数小的补足了空格。
回到家里上网查了一下，找到答案了，大概摘录一下，给自己以后提个醒，如果有什么不对的地方希望那个大家批评指教！！！

Oracle使用以下两种比较规则：
1、空格补齐比较语法
对于类型CHAR、NCHAR、text literals、USER函数值, 在进行比较时, 先在较短的那个
字符串后补上空格以使长度相等, 然后再进行比较. 注意b.toId = ‘12345678’也会是true的
2、非补齐比较语法
对于类型VARCHAR2、NVARCHAR2, 则不用补齐, 直接进行比较.

最近见版内对String讨论的帖子很多，但是又众说风云，为了让大家彻底理解String这个特殊对象，我趁此机会来对String对象做进一步的分析。

友情提示：希望在阅读之前，你已经对String对象有了基础的了解。并且已经熟知"类型"、"引用"、"对象"、"实例化"、"堆栈"和关于Object对象的equals()方法的使用机制，并且已经熟知String对象对equals()方法重写后的使用机制！

首先大家知道，String既可以作为一个对象来使用，又可以作为一个基本类型来使用。这里指的作为一个基本类型来使用只是指使用方法上的，比如String s = "Hello"，它的使用方法如同基本类型int一样，比如int i = 1;，而作为一个对象来使用，则是指通过new关键字来创建一个新对象，比如String s = new String("Hello")。但是它的内部动作其实还是创建了一个对象，这点稍后会说到。

其次，对String对象的比较方法需要了解。Java里对象之间的比较有两种概念，这里拿String对象来说：一种是用"=="来比较，这种比较是针对两个String类型的变量的引用，也就是说如果两个String类型的变量，它们所引用同一个String对象(即指向同一块内存堆)，则"=="比较的结果是true。另一种是用Object对象的equals()方法来比较，String对象继承自Object，并且对equals()方法进行了重写。两个String对象通过equals()方法来进行比较时，其实就是对String对象所封装的字符串内容进行比较，也就是说如果两个String对象所封装的字符串内容相同(包括大小写相同)，则equals()方法将返回true。

现在开始将对String对象的创建做具体的分析。

首先看以下代码段：

String s1 = new String("Hello");
String s2 = new String("Hello");

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

以上代码段的打印结果是：

false
true

这个结果相信大家很好理解，两个String类型的变量s1和s2都通过new关键字分别创建了一个新的String对象，这个new关键字为创建的每个对象分配一块新的、独立的内存堆。因此当通过"=="来比较它们所引用的是否是同一个对象时，将返回false。而通过equals()方法来比较时，则返回true，因为这两个对象所封装的字符串内容是完全相同的。

好，现在把上面的代码段修改如下：

String s1 = new String("Hello");
String s2 = s1;

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

以上代码段的打印结果是：

true
true

这个结果应该更好理解，变量s1还是通过new关键字来创建了一个新的String对象，但这里s2并没有通过new关键字来创建一个新的String对象，而是直接把s1赋值给了s2，即把s1的引用赋值给了s2，所以s2所引用的对象其实就是s1所引用的对象。所以通过"=="来比较时，返回true。既然它们引用的都是同一个对象，那么通过equals()方法来比较时，肯定也返回true，这里equals()方法其实在对同一个对象进行比较，自己肯定等于自己咯。

说到此，其实应该没什么大问题，因为这些都是标准的创建对象的动作，但是String对象还有另一种使用方法，也就是开头所提到的可以作为一个基本类型来使用，请看以下代码段：

String s = "Hello";

看到这里，相信一些初学的朋友或者对String对象还没搞清楚的朋友开始疑惑了，你肯定会问，这个使用方法在其内部到底发生了什么？其实这就是String对象容易混淆的关键！

其实在启动程序时，虚拟机会创建一块String对象的String缓冲池。当String对象作为一个基本类型来使用时，比如：String s = "Hello";，虚拟机会先在这个String缓冲池内寻找是否有相同值的String对象存在，如果存在，则把这个String对象的引用赋值给s。如果不存在，虚拟机会先在这个String缓冲池内创建此String对象，然后把引用赋值给s。

说到这里，相信大家已经开始明白了。那么请看下面的代码段：

String s1 = "Hello";
String s2 = "Hello";

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

以上代码段的打印结果是：

true
true

为什么这个结果？那么来分析一下。首先这两个String对象都是作为一个基本类型来使用的，而不是通过new关键字来创建的，因此虚拟机不会为这两个String对象分配新的内存堆，而是到String缓冲池中来寻找。

首先为s1寻找String缓冲池内是否有与"Hello"相同值的String对象存在，此时String缓冲池内是空的，没有相同值的String对象存在，所以虚拟机会在String缓冲池内创建此String对象，其动作就是new String("Hello");。然后把此String对象的引用赋值给s1。

接着为s2寻找String缓冲池内是否有与"Hello"相同值的String对象存在，此时虚拟机找到了一个与其相同值的String对象，这个String对象其实就是为s1所创建的String对象。既然找到了一个相同值的对象，那么虚拟机就不在为此创建一个新的String对象，而是直接把存在的String对象的引用赋值给s2。

这里既然s1和s2所引用的是同一个String对象，即自己等于自己，所以以上两种比较方法都返回ture。

到这里，对String对象的基本概念应该都已经理解了。现在我来小结一下：

针对String作为一个基本类型来使用：

1。如果String作为一个基本类型来使用，那么我们视此String对象是String缓冲池所拥有的。
2。如果String作为一个基本类型来使用，并且此时String缓冲池内不存在与其指定值相同的String对象，那么此时虚拟机将为此创建新的String对象，并存放在String缓冲池内。
3。如果String作为一个基本类型来使用，并且此时String缓冲池内存在与其指定值相同的String对象，那么此时虚拟机将不为此创建新的String对象，而直接返回已存在的String对象的引用。

针对String作为一个对象来使用：

1。如果String作为一个对象来使用，那么虚拟机将为此创建一个新的String对象，即为此对象分配一块新的内存堆，并且它并不是String缓冲池所拥有的，即它是独立的。

理解了以上内容后，请看以下代码段：

String s1 = "Hello";
String s2 = new String("Hello");

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

以上代码段的打印结果是：

false
true

根据上面的小结来进行分析。第一行是把String作为一个基本类型来使用的，因此s1所引用的对象是属于String缓冲池内的。并且此时String缓冲池内并没有与其值相同的String对象存在，因此虚拟机会为此创建一个新的String对象，即new String("Hello");。第二行是把String作为一个对象来使用的，因此s2所引用的对象不属于String缓冲池内的，即它是独立的。通过new关键字，虚拟机会为此创建一个新的String对象，即为它分配了一块新的内存堆。因此"=="比较后的结果是false，因为s1和s2所引用的并不是同一个对象，它们是独立存在的。而equals()方法所返回的是true，因为这两个对象所封装的字符串内容是完全相同的。

现在，相信大家已经完全搞清楚String对象是怎么一回事了：）但是到此并没有结束，因为String对象还有更深层次的应用。

这里我将分析一下String对象的intern()方法的应用。
intern()方法将返回一个字符串对象的规范表示法，即一个同该字符串内容相同的字符串，但是来自于唯一字符串的String缓冲池。这听起来有点拗口，其实它的机制有如以下代码段：

String s = new String("Hello");
s = s.intern();

以上代码段的功能实现可以简单的看成如下代码段：

String s = "Hello";

你一定又开始疑惑了？那么你可以先看第二个代码段。第二个代码段的意思就是从String缓冲池内取出一个与其值相同的String对象的引用赋值给s。如果String缓冲池内没有与其相同值的String对象存在，则在其内为此创建一个新的String对象。那么第一段代码的意思又是什么呢？我们知道通过new关键字所创建出的对象，虚拟机会为它分配一块新的内存堆。如果平凡地创建相同内容的对象，虚拟机同样会为此分配许多新的内存堆，虽然它们的内容是完全相同的。拿String对象来说，如果连续创建10个相同内容的String对象(new String("Hello"))，那么虚拟机将为此分配10块独立的内存堆。假设所创建的String对象的字符串内容十分大，假设一个Stirng对象封装了1M大小的字符串内容，那么如果我们创建10个此相同String对象的话，我们将会毫无意义的浪费9M的内存空间。我们知道String是final类，它所封装的是字符串常量，因此String对象在创建后其内部(字符串)值不能改变，也因此String对象可以被共享。所以对于刚才提到的假设，我们所创建的10个相同内容的String对象，其实我们只需为此创建一个String对象，然后被其它String变量所共享。要实现这种机制，唯一的、简单的方法就是使用String缓冲池，因为String缓冲池内不会存在相同内容的String对象。而intern()方法就是使用这种机制的途径。在一个已实例化的String对象上调用intern()方法后，虚拟机会在String缓冲池内寻找与此Stirng对象所封装的字符串内容相同值的String对象，然后把引用赋值给引用原来的那个String对象的String类型变量。如果String缓冲池内没有与此String对象所封装的字符串内容相同值的String对象存在，那么虚拟机会为此创建一个新的String对象，并把其引用赋值给引用原来的那个String对象的String类型变量。这样就达到了共享同一个String对象的目的，而原先那个通过new关键字所创建出的String对象将被抛弃并被垃圾回收器回收掉。这样不但降低了内存的使用消耗，提高了性能，而且在String对象的比较上也同样更方便了，因为相同的String对象将被共享，所以要判断两个String对象是否相同，则只需要使用"=="来比较，而无需再使用equals()方法来比较，这样不但使用起来更方便，而且也提高了性能，因为String对象的equals()方法将会对字符串内容拆解，然后逐个进行比较，如果字符串内容十分大的话，那么这个比较动作则大大降低了性能。

说到此，大家可能对具体应用还有点模糊，那么我来举个简单的示例，以便阐述以上概念：

假设有一个类，它有一个接收消息的方法，这个方法记录用户传来的消息(假设消息内容可能较大，并且重复率较高)，并且把消息按接收顺序记录在一个列表中。我想有些朋友会这样设计：

import java.util.*;

public class Messages {

ArrayList messages = new ArrayList();

public void record(String msg) {
messages.add(msg);
}

public List getMessages() {
return messages;
}
}

这种设计方案好吗？假设我们重复的发送给record()方法同一个消息(消息来自不同的用户，所以可以视每个消息为一个new String("..."))，并且消息内容较大，那么这个设计将会大大浪费内存空间，因为消息列表中记录的都是新创建的、独立的String对象，虽然它们的内容都相同。那么怎么样可以对其进行优化呢，其实很简单，请看如下优化后的示例：

import java.util.*;

public class Messages {

ArrayList messages = new ArrayList();

public void record(String msg) {
messages.add(msg.intern());
}

public List getMessages() {
return messages;
}
}

正如你所看到的，原先record()方法中的messages.add(msg);代码段变成了messages.add(msg.intern());，仅仅对msg参数调用了intern()方法，这样将对重复的消息进行共享机制，从而降低了内存消耗，提高了性能。

这个例子的确有点牵强，但是这里只是为了阐述以上概念！

至此，String对象的迷雾都被消除了，大家只要牢记这些概念，以后再复杂的String应用都可以建立在此基础上来进行分析。