String,static,堆栈，文件与I/O流，数据库

String

一、java中常用的String方法

1、int  length()    求字符串的长度

2、char  charAt(int index)  返回指定索引处的char值。索引范围为0到length()-1

3、boolean equals(Object  anObject)   将此字符串与指定的对象比较。

4、boolean  startsWith( String  prefix ) 和endsWith(String  suffix )　  

   测试此字符串是否以指定的前缀/后缀结束
5、int  indexOf( int ch) 和lastIndexOf( int ch)   查找字符或者子串第一次出现的索引

6、String  substring(int startIndex)   

   返回一个新的字符串，该子字符串从指定索引处的字符开始，直到此字符串末尾。

　 String  substring(int startIndex,int endIndex)

   返回一个新字符串，该子字符串是beginIndex处开始，直到索引endIndex - 1处的字符。

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

8、String  trim()   去掉起始和结尾的空格

9、String  toLowerCase() 转换为小写   和  toUpperCase() 转换为大写

10、String[]  split(String regex)  根据给定的正则表达式匹配拆分此字符串。

二、equals()  与  ==

 equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。
　　例：String s1="Hello";
　　　　String s2=new String(s1);
　　　　s1.eauals(s2); //true
　　　　s1==s2;//false

三、String对象的创建

原理1：当使用任何方式来创建一个字符串对象 s时，Java运行时（运行中JVM）会拿着这个X在String池中找是否存在内容相同的字符串对象，如果不存在，则在池中创建一个字符串s，否则，不在池中添加。

原理2：Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。

原理3：使用直接指定或者使用纯字符串串联来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象。

原理4：使用包含变量的表达式来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String对象。

String a;  申明一个string类型的 a，即没有在申请内存地址，更没有在内存任何指向引用地址;

String a = null ;   申明一个string类型的 a，同时在内存里申请了一个地址，但是该地址不指向任何引用地址；

String a = "" ;申明一个string类型的 a，既在内存里申请了地址，该地址又指向一个引用该字符串的引用地址；

一般来说 字符串的使用 最好用String a = "" ;语句，可以防止后面的程序因引用地址混乱而找不到的异常！ String a = null ;   String a;  劲量少用！  能不用就不要使用!

数据库常用语句：

(1) 数据记录筛选： 

sql="select * from 数据表 where 字段名=字段值 order by 字段名 " 

sql="select * from 数据表 where 字段名 like‘%字段值%‘order by 字段名 asc / desc" 

sql="select top 10 * from 数据表 where 字段名 order by 字段名 " 

sql="select * from 数据表 where 字段名 in (‘值1‘,‘值2‘,‘值3‘)" 

sql="select * from 数据表 where 字段名 between 值1 and 值2" 

(2) 更新数据记录： 

sql="update 数据表 set 字段1=值1,字段2=值2 …… 字段n=值n where 条件表达式" 

(3) 删除数据记录： 

sql="delete from 数据表 [where 条件表达式]" 

(4) 添加数据记录： 

sql="insert into 数据表 (字段1,字段2,字段3 …) valuess (值1,值2,值3 …)" 

sql="insert into 目标数据表 select * from 源数据表" 

(5) 数据记录统计函数： 

AVG(字段名) 平均值            COUNT(*|字段名) 对数据行数的统计 

MAX(字段名) 最大值            MIN(字段名) 最小值 

SUM(字段名) 把数据栏的值相加 

引用以上函数的方法： 

sql="select  sum(字段名)  as 别名 from 数据表 where 条件表达式" 

(6) 数据库的创建与删除

create database  database-name ;            drop database dbname ;

(7) 数据表的常用语句

1.创建新表
create table tabname(col1 type1 [not null] [primary key],col2 type2 [not null],..)根据已有的表创建新表：
A：create table tab_new like tab_old (使用旧表创建新表)
B：create table tab_new as select col1,col2… from tab_old 
2.删除新表   drop  able  tabname

3. 增加一个列   Alter  table  tabname  add  column  col  type

4.添加主键：Alter table tabname add primary key(col)
  删除主键：Alter table tabname drop primary key(col)

5.修改数据类型：Alter  table  表名 modify  colunm  列名  数据类型[长度] 

(8) 索引 ：使用索引可快速访问数据库表中的特定信息

创建索引：create [unique] index idxname on tabname(col….)
删除索引：drop index idxname
注：索引是不可更改的，想更改必须删除重新建。

(9) 视图 ：视图是一种虚拟的表，具有和物理表相同的功能。可以对视图进行增，改，查，操作，试图通常是有一个表或者多个表的行或列的子集。对视图的修改不影响基本表。它使得我们获取数据更容易，相比多表查询。

创建视图：create view viewname as select statement
删除视图：drop view viewname

(10) 游标 ：是对查询出来的结果集作为一个单元来有效的处理。游标可以定在该单元中的特定行，从结果集的当前行检索一行或多行。可以对结果集当前行做修改。一般不使用游标，但是需要逐条处理数据的时候，游标显得十分重要。
申明游标：declare <游标名>  cursor  for <select  子句>

‚打开游标：open  <游标名>

ƒ移动游标：fetch [ [ next | prior | first | last ] from ] <游标名> into <主变量>[指示变量]..

④关闭游标：close  <游标名>

(11) 触发器：是特定事件出现的时候，自动执行的代码块。类似于存储过程，但是用户不能直接调用他们。

Create Trigger [TriggerName]   ON [TableName]  FOR [Insert][,Delete][,Update]

AS  触发器要执行的操作语句.

************************通配符************************

1.%: 代表任意多个字符   name LIKE '李%'

2._ (下划线): 代表任意一个字符

3.[ ]: 指定范围的一个字符   如:Sex LIKE '[男女]'   StuID LIKE [0-9][0-9]

4.IN: 限制范围   StuID IN(0,1,2,3,4,5,6,7,8,9)

5.[^ ]: 不在指定范围里的一个字符  

6.age>=0 and age<=100 相当于age  BETWEEN  0  AND  100

二、几个高级查询运算词

A： UNION 运算符 

UNION运算符通过组合其他两个结果表（例如TABLE1和TABLE2）并消去表中任何重复行而派生出一个结果表。当ALL随UNION一起使用时（即UNION ALL），不消除重复行。两种情况下，派生表的每一行不是来自TABLE1就是来自TABLE2。 

B： EXCEPT 运算符 

EXCEPT 运算符通过包括所有在 TABLE1 中但不在 TABLE2 中的行并消除所有重

复行而派生出一个结果表。当 ALL 随 EXCEPT 一起使用时 (EXCEPT ALL)，不消

除重复行。 

C： INTERSECT 运算符

INTERSECT 运算符通过只包括 TABLE1 和 TABLE2 中都有的行并消除所有重复行而派生出一个结果表。当 ALL 随 INTERSECT 一起使用时 (INTERSECT ALL)，不消除重复行。 

注：使用运算词的几个查询结果行必须是一致的。 

三、使用外连接 

A、left （outer） join： 左外连接（左连接）：结果集几包括连接表的匹配行，也包括左连接表的所有行

  select a.a, a.b, a.c, b.c, b.d, b.f 

  from a LEFT OUT JOIN b 

  ON a.a = b.c

B：right （outer） join: 右外连接(右连接)：结果集既包括连接表的匹配连接行，也包括右连接表的所有行。 

C：full/cross （outer） join： 全外连接：不仅包括符号连接表的匹配行，还包括两个连接表中的所有记录。

总结关键字static的用法

1．关键字static（先记住这些，再往下看）

1）静态方法和静态变量是属于某一个类，而不属于类的对象。

2）静态方法和静态变量的引用直接通过类名引用。

3）在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之，则可以。

4）静态变量在某种程序上与其他语言的全局变量相类似，如果不是私有的就可以在类的外部进行访问。

2．何时使用static

在我们创建一个类的实例时（对象），通常使用new方法，这样这个类的数据空间才会被创建，其方法才能被调用。

     1 . 但是，有时候我们希望一个类虽然可以被创建n个对象（显然这n个对象的数据空间是不相同的），但这n个对象的某些数据是相同的，即不管这个类有多少的实例，这些数据对这些实例而言之有一份内存拷贝（见示例1）。这是静态变量的情形。

示例1

public class TStatic {

    static int i;

    public TStatic() {

       i = 4;

    }

    public TStatic(int j) {

       i = j;

    }

    public static void main(String args[]) {

       System.out.println(TStatic.i);

       TStatic t = new TStatic(5); // 声明对象引用，并实例化。此时i=5

       System.out.println(t.i);

       TStatic tt = new TStatic(); // 声明对象引用，并实例化。此时i=4

       System.out.println(t.i);

       System.out.println(tt.i);

       System.out.println(t.i);

    }

}

 

结果：

0

5

4

4

4

static变量在类被载入时创建，只要类存在，static变量就存在。它们在定义时必须进行初始化。上例中没有初始化i,所以会得到默认的初始值0。static的变量的初始化仅能一次，static变量只是接受了最后一次的初始化。

实际这还是多个实例共享一个静态的变量的问题。

 2. 另一种情形是，你希望某个方法不与包含它的类的任何对象关联在一起。也就是说，即使没有创建对象，也能够调用这个方法。static 方法的一个重要用法就是在不创建任何对象的前提下，就可以调用它（见示例2）。这是静态方法的情形。

示例2

未声明为static

class ClassA {

    int b;

    public void ex1() {}

    class ClassB {

       void ex2() {

           int i;

           ClassA a = new ClassA();

           i = a.b; // 这里通过对象引用访问成员变量b

           a.ex1(); // 这里通过对象引用访问成员函数ex1

       }

    }

}

 

声明为static

class ClassA {

    static int b;

    static void ex1() {}

}

class ClassB {

    void ex2() {

       int i;

       i = ClassA.b; // 这里通过类名访问成员变量b

       ClassA.ex1(); // 这里通过类名访问成员函数ex1

    }

}

在使用静态方法时要注意，在静态方法中不能调用非静态的方法和引用非静态的成员变量（在static方法中也不能以任何方式引用this或super）。理由很简单，对于静态的东西，JVM在加载类时，就在内存中开辟了这些静态的空间（所以可以直接通过类名引用），而此时非静态的方法和成员变量所在的类还没有实例化。

所以如果要使用非静态的方法和成员变量，可以直接在静态方法中实例化该方法或成员变量所在的类。public static void main就是这么干的。

3. 还有一种特殊的用法出现在内部类中，通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类（见示例3）。这是静态类的情形。

示例3

public class StaticCls {

    public static void main(String[] args) {

       OuterCls.InnerCls oi = new OuterCls.InnerCls();// 这之前不需要new一个OuterCls

    }

}

class OuterCls {

    public static class InnerCls {

       InnerCls() {

           System.out.println("InnerCls");

       }

    }

}

 

结果：

InnerCls

扩展：j ava 默认的修饰符 

/**
     * 默认访问符是friendly,也就是包级访问权限
     * private 表示只能类内部可以访问
     * public 所以都可以访问

     * protected 表示子类、内部、包级都可以访问
     *
     */
  类 默认是friendly
  方法 默认是 friendly 
  字段   默认是 friendly 
  接口 默认是public 

//红色表示包级可以有访问权限 

3．静态初始化

static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。静态代码块（在“static{”后面跟着一段代码），是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。看下面示例。

class Value {

    static int c = 0;

 

    Value() {

       c = 15;

    }

 

    Value(int i) {

       c = i;

    }

 

    static void inc() {

       c++;

    }

}

 

class Count {

    public static void prt(String s) {

       System.out.println(s);

    }

 

    Value v = new Value(10);

 

    static Value v1, v2;

    static {

       prt("in the static block of calss Count v1.c=" + v1.c + "  v2.c="

              + v2.c);

       v1 = new Value(27);

       prt("in the static block of calss Count v1.c=" + v1.c + "  v2.c="

              + v2.c);

       v2 = new Value();

       prt("in the static block of calss Count v1.c=" + v1.c + "  v2.c="

              + v2.c);

    }

}

 

public class TStaticBlock {

    public static void main(String[] args) {

       Count ct = new Count();

       Count.prt("in the main:");

       Count.prt("ct.c=" + ct.v.c);

       Count.prt("v1.c=" + Count.v1.c + "  v2.c=" + Count.v2.c);

       Count.v1.inc();

       Count.prt("v1.c=" + Count.v1.c + "  v2.c=" + Count.v2.c);

       Count.prt("ct.c=" + ct.v.c);

    }

}

 

结果：

in the static block of calss Count v1.c=0  v2.c=0

in the static block of calss Count v1.c=27  v2.c=27

in the static block of calss Count v1.c=15  v2.c=15

in the main:

ct.c=10

v1.c=10  v2.c=10

v1.c=11  v2.c=11

ct.c=11

不管是v,v1还是v2，它们操作的成员变量都是同一个静态变量c。

在类Count中先初始化v1，v2（static Value v1, v2;），再初始化静态代码块（static{}），最后初始化v。

同时可看出static方法是调用后才加载的。或者是在本类中的main方法中直接调用static方法（已经过实验），或者用类直接调用，如Math.pow(int x,int a).总之，static方法要经过调用。（这段话话是我写的）

static

    被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用 

    用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块

1.static变量

    按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 

对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2.static方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3.static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。即所有静态初始化语句和静态初始化块都依照类定义的顺序执行。

4、static和final一块用表示什么 

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 对于方法，表示不可覆盖，并且可以通过类名直接访问。

什么时候使用static：

首先我们先来分析下main()方法，大家都知道main()方法是static的，那为什么呢？因为mian()是程序执行的入口点，每个类都要执行它，说通俗点：mian()方法是《抢手货》，频繁的调用。所以：

一、对象、变量、方法需要频繁的建立、使用、调用时，使用static关键字。

例如：单例类，对数据库操作类，字符串处理等。

二、与类、对象的状态无关时，使用static关键字。

例如：java.lang.math包下的所有方法，都是static，因为他没有状态，只是执行下操作或者改变一个变量而已。

另一种描述（来自java核心技术）：

第一种情况：一个方法不需要访问对象状态，其所需参数都是通过显示参数提供，例如Math.pow方法。

第二种情况：一个方法只需要访问类地静态域，如JFrame.EXIT_ON_CLOSE.

private static 和public static 的区别 

private static  和  public static 都是静态变量,在类加载时就定义,不需要创建对象,但是private static 是私有的,不能在外部访问,只能通过静态方法调用,这样可以防止对变量的修改public static 是公开的,在外部就可以访问,且可以对该值修改,在编程中,如果不希望静态变量随意修改,就应该声明private(私有)的,这样外部不能随意修改,此时在把构造函数私有,这样这个变量就没有办法使用一般方法修改了如果使用公开的,则可以在任意地方对其进行修改static是说不用实例化就可以调用其值private是说此值只能本类访问所以private static声明的变量，只能在本类中的方法被访问，且不需要实例化本类。

Java中static、final用法小结 

一、final

1.final变量：

      当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。

     当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用

2.final方法

     如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 使用final方法的原因有二：     第一、把方法锁定，防止任何继承类修改它的意义和实现。     第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

3.final类

      final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

4、static和final一块用表示什么

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 对于方法，表示不可覆盖，并且可以通过类名直接访问。

Java栈与堆

1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

3. Java中的数据类型有两种。

一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。

另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
复制内容到剪贴板代码:
int a = 3;
int b = 3；
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。 4. String是一个特殊的包装类数据。即可以用String str = new String("abc");的形式来创建，也可以用String str = "abc"；的形式来创建(作为对比，在JDK 5.0之前，你从未见过Integer i = 3;的表达式，因为类与字面值是不能通用的，除了String。而在JDK 5.0中，这种表达式是可以的！因为编译器在后台进行Integer i = new Integer(3)的转换)。前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类的实例，全部通过new()的形式来创建。Java中的有些类，如DateFormat类，可以通过该类的getInstance()方法来返回一个新创建的类，似乎违反了此原则。其实不然。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部通过new()来创建的，而getInstance()向外部隐藏了此细节。那为什么在String str = "abc"；中，并没有通过new()来创建实例，是不是违反了上述原则？其实没有。

5. 关于String str = "abc"的内部工作。Java内部将此语句转化为以下几个步骤：

(1)先定义一个名为str的对String类的对象引用变量：String str；

(2)在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"的地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并返回o的地址。

(3)将str指向对象o的地址。

值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用！

为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。
复制内容到剪贴板代码:
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
注意，我们这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象。

我们再来更进一步，将以上代码改成：
复制内容到剪贴板代码:
String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
System.out.println(str1 + "," + str2); //bcd, abc
System.out.println(str1==str2); //false
这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！而str2仍旧指向原来的对象。上例中，当我们将str1的值改为"bcd"时，JVM发现在栈中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值指向这个地址。

事实上，String类被设计成为不可改变(immutable)的类。如果你要改变其值，可以，但JVM在运行时根据新值悄悄创建了一个新对象，然后将这个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的，但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中，会带有一定的不良影响。

再修改原来代码：
复制内容到剪贴板代码:
String str1 = "abc";
String str2 = "abc";

str1 = "bcd";

String str3 = str1;
System.out.println(str3); //bcd

String str4 = "bcd";
System.out.println(str1 == str4); //true
str3这个对象的引用直接指向str1所指向的对象(注意，str3并没有创建新对象)。当str1改完其值后，再创建一个String的引用str4，并指向因str1修改值而创建的新的对象。可以发现，这回str4也没有创建新的对象，从而再次实现栈中数据的共享。

我们再接着看以下的代码。
复制内容到剪贴板代码:
String str1 = new String("abc");
String str2 = "abc";
System.out.println(str1==str2); //false 创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1==str2); //false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

6. 数据类型包装类的值不可修改。不仅仅是String类的值不可修改，所有的数据类型包装类都不能更改其内部的值。

7. 结论与建议：

(1)我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，我们创建了String类的对象str。担心陷阱！对象可能并没有被创建！唯一可以肯定的是，指向String类的引用被创建了。至于这个引用到底是否指向了一个新的对象，必须根据上下文来考虑，除非你通过new()方法来显要地创建一个新的对象。因此，更为准确的说法是，我们创建了一个指向String类的对象的引用变量str，这个对象引用变量指向了某个值为"abc"的String类。清醒地认识到这一点对排除程序中难以发现的bug是很有帮助的。

(2)使用String str = "abc"；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。这个思想应该是享元模式的思想，但JDK的内部在这里实现是否应用了这个模式，不得而知。

(3)当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==。

(4)由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。

模拟堆栈：

public class ArrayStack{

   Object[]  o;

   int a;

   public ArrayStack(int b){

      o=new Object[b];

      a=0;

   }

   public ArrayStack(){

      this(50);

   }

   //insert into stack

   public void push(Object obj){

         o[a] = obj;

         a++;

   }

   //return and remove the top element

    public Object pop(){

       if(!this.isEmpty){

           Object object=o[a-1];

           o[a-1]=null;

           a--;

           return object;

        }else{ 

            return null;

        }

    }

}

文件与I/O流

    java.io包支持两种流：“字节流”和“字符流”。当向字节流中写入数据时，数据是以字节（byte）为单位的序列，与内存中形式相同，不发生任何转换。而字符流则是以字符为单位的数据序列。

Java中实现字节流的基类是InputStream和OutputStream，它们均直接继承自Object类。InputStream和OutputStream均是抽象类，定义了输入和输出字节的基本操作。它派生出了大量的具体功能的类。

Java中实现字符流的基类是Reader和Writer，它们均直接继承自Object类。Reader和Writer也是抽象类，定义了输入和输出字符的基本操作。用户不能直接创建其对象，只能通过其子类来创建。

标准数据流

   在Java应用程序开始执行时，会自动创建3个标准数据流，供System类使用： System.in、System.out和System.err

System.in对象：是InputStream类型的，是连接程序与标准输入设备（通常是键盘）的一个输入流对象，当执行System.in.read()操作时，从键盘得到输入数据。

System.out对象：是PrintStream类型的，是连接程序和标准输出设备（通常是显示器）的一个输出流对象，当执行System.out.println()语句时，数据输出到屏幕上。

System.err对象：标准错误输出流。

从键盘获取数据

System.in 是个已定义好的 InputStream 类型的对象，用以获取键盘输入。但其返回的值是键盘的ASCII码值，须经转换才能显示为字符。 

推荐的获取键盘输入的方式：

BufferedReader buf= new BufferedReader( new InputStreamReader(System.in));

try {

   String str=buf.readLine();

   System.out.println("从键盘输入的数据是：" + str);

} catch (IOException e) {

   e.printStackTrace();

}

Java文件操作

Java 1.4后引入新的文件功能，提高了I/O性能，但增加了复杂性。

新的I/O功能中涉及文件读写方面的有3个对象：

文件流对象：FileInputStream、FileOutputStream.

缓冲区对象：存放与文件进行传输的数据。

通道对象：连接文件，使用一个或多个缓冲区对象以对文件进行读写。

 

缓冲区（buffer）

缓冲区是内存中的一块区域，用以缓存程序与外设间交互的数据。

Buffer类是定义所以缓冲区类的基类，一个特定的缓冲区可存储一组给定类的数据单元，例如存储byte型值、 char型值、 short型值、 int型值、 long型值、 float型值、 double型值，但不能存储boolean型值。

缓冲区的容量：缓冲区存储指定数据单元的最大数，而不是存储的最大字节数。例如IntBuffer型缓冲区容量是存储Int型数值的个数。

缓冲区的位置：要读写的下一个缓冲区单元的下标（首单元下标为0）。

缓冲区的边界：不能读写的第一个单元的下标

 

创建缓冲区：

    ByteBuffer buf = ByteBuffer.allocate(1024);

向缓冲区写入数据：

    buf.put(bytes);//bytes是byte[]型数据

    buf.putChar();

    buf.putInt();

    .....

从缓冲区读出数据：

    buf.put(bytes);//bytes是byte[]型数据

    buf.putChar();

    buf.putInt();

    .....

通道（channel）

FileChannel类不能直接实例化其对象，可从其它流类获得。

FileChannel类不能直接实例化其对象，可从其它流类获得。

通道使用完毕后，须关闭：调用其 close()方法。关闭通道只是断开了同文件的连接，并不影响所连接的文件。通道关闭后则不能再传输数据。判断通道是否处于打开状态，可使用方法isOpen()。

文件

File类主要用于获取磁盘中文件或目录的信息。File类的对象并不打开文件，也不提供任何文件处理功能。然而，java.io包中的其它类经常使用File对象来指定所要操作的文件或目录。File类的实例表示主机文件系统中的文件名或路径名。

File类提供4个构造函数

public File(String name)

public File(String pathToName,String name)

public File(File directory,String name)

public File(URI uri)

File类提供了30多种方法以操作File对象：

getName()//返回所关联的文件或目录的名称 

getPath() ()//返回文件的路径 

isAbsolute() ()//是否是绝对路径 

list() ()//返回目录下的所有目录和文件名 

isFile() ()//是否关联的是文件 

isDirectory() ()//是否关联的是目录 

delete() ()//删除所关联的文件或目录 

......

文件流

当向磁盘上的物理文件读写数据时，可使用文件流FileInputStream和FileOutputStream。

创建文件流对象（以写文件为例）：

FileOutputStream outFile = new FileOutputStream （“myFile.txt”）;

FileOutputStream outFile = new FileOutputStream （“myFile.txt”,true）;

写文件的示例程序：WriteFile.java

读文件的示例程序：ReadFile.java

复制文件的示例程序：CopyFile.java

java 文件操作实例(列出文件目录,创建文件,按字节读入数据,按行读入数据等 

public class Testfile {
public static void main(String[] args) {
  
/*=======读取并写入文件===============================*/
//   try {
// //   FileInputStream f = new FileInputStream("f:\\test\\test.txt");
//   
//    FileReader rd=new FileReader("f:\\test\\aa.txt");
//    BufferedReader br=new BufferedReader(rd);
//    File ff=new File("f:\\");
//    int i=0;
//    File[] files=ff.listFiles();
//    for(File aa:files){
//     System.out.println(aa);
//     i++;
//    }
//    System.out.print("共有文件或文件夹"+i+"个");
//   
////    boolean xx=ff.createNewFile();
//   
//    System.out.print(ff.getName()+"        "+ff.canRead());
   
//    if (xx==true)System.out.println("文件创建成功，开始写入数据");
//    else System.out.println("文件已经存在");
//    FileWriter fw=new FileWriter("f:\\test\\test.dat");
//    BufferedWriter bw=new BufferedWriter(fw);
//    String x;      
//    String s;
//    int i=0;
//    while((s=br.readLine())!=null){
//     if(i!=0)System.out.print("\n");
//     System.out.print(s);
//     bw.flush();
//     if(i!=0)bw.newLine();
//     bw.write(s);
//     if(i==0)i++;
//
//    }
//    bw.close();
//    fw.close();
//    br.close();
//    rd.close();
//
//   } catch (FileNotFoundException e) {
//    // TODO Auto-generated catch block
//    e.printStackTrace();
//   } catch (IOException e) {
//    // TODO Auto-generated catch block
//    e.printStackTrace();
//   }
/*========end读取并写入文件==============================*/

/**======文本文件的创建========================= 
   File ff=new File("f:\\test\\test.txt");
   try {
    boolean exists=ff.createNewFile();
//    System.out.print(exists);
    if(exists==false)System.out.println("文件已存在");
    else System.out.println("文件创建成功");
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
=========end文本文件的创建==============================*/

/**==文本文件按指定字节数读取操作===================================*/

   try {
    FileInputStream f = new FileInputStream("f:\\test\\aa.txt");
    int len=f.available();
    byte[] b=new byte[len];
  
    int byteRead = f.read(b);
    while (byteRead!=-1) {
     String x=new String(b,"GBK");
     System.out.print(x);
     byteRead = f.read(b);
    }
   } catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
/*==end文本文件读取操作===================================*/
  
/**==文本文件按单字节读取操作===================================

   try {
    FileInputStream f = new FileInputStream("f:\\test\\test.txt");
  
    int byteRead = f.read();
    while (byteRead!=-1) {
    
     System.out.print((char)byteRead);
     byteRead = f.read();
    }
   } catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
==end文本文件读取操作===================================*/  
}
}

Java的IO操作都是基于流进行操作的，为了提高读写效率一般需要进行缓冲。 
    简单的示例程序如下：
    
    /**
 * 读出1.txt中的内容，写入2.txt中
 *
 */ 
import java.io.*; 
public class ReadWriteFile{
 public static void main(String[] args){
  try{
   File read = new File("c:\\1.txt");
   File write = new File("c:\\2.txt");
   
   BufferedReader br = new BufferedReader(new FileReader(read));
   BufferedWriter bw = new BufferedWriter( new FileWriter(write));
   String temp = null;
   temp = br.readLine();
   while(temp != null){
    //写文件
    bw.write(temp + "\r\n"); //只适用Windows系统
    //继续读文件
    temp = br.readLine();
   }
   bw.close();
   br.close();
  }catch(FileNotFoundException e){ //文件未找到
   System.out.println (e);
  }catch(IOException e){
   System.out.println (e);
  } 
 } 
}