type arrayName[ ]；
　　类型(type)可以为Java中任意的数据类型，包括简单类型和复合类型。
　　例如：
　　　int intArray[ ]；
　　　Date dateArray[];

　　2．一维数组的初始化

　　◇ 静态初始化
　　　　int intArray[]={1,2,3,4};
　　　　String stringArray[]={"abc", "How", "you"};

　　◇ 动态初始化
　　　 1）简单类型的数组
　　　　int intArray[];
　　　　intArray = new int[5];

　　　2）复合类型的数组
　　　　String stringArray[ ];
　　　　String stringArray = new String[3];/*为数组中每个元素开辟引用
　　　　　　　　　　　　　　　　　　　　　 空间(32位) */
　　　　stringArray[0]= new String("How");//为第一个数组元素开辟空间
　　　　stringArray[1]= new String("are");//为第二个数组元素开辟空间
　　　　stringArray[2]= new String("you");// 为第三个数组元素开辟空间

　　3．一维数组元素的引用

　　数组元素的引用方式为：
　　　　　arrayName[index]

　　index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。

★多维数组

　　Java语言中，多维数组被看作数组的数组。

　　1．二维数组的定义

　　type arrayName[ ][ ]；
　　type [ ][ ]arrayName;

　　2．二维数组的初始化

　　◇ 静态初始化
　　int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};

　　Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。

　　◇ 动态初始化
　　1) 直接为每一维分配空间，格式如下：
　　arrayName = new type[arrayLength1][arrayLength2];
　　int a[ ][ ] = new int[2][3]；

　　2) 从最高维开始，分别为每一维分配空间：
　　arrayName = new type[arrayLength1][ ];
　　arrayName[0] = new type[arrayLength20];
　　arrayName[1] = new type[arrayLength21];
　　…
　　arrayName[arrayLength1-1] = new type[arrayLength2n];

　　3) 例：
　　二维简单数据类型数组的动态初始化如下,
　　int a[ ][ ] = new int[2][ ]；
　　a[0] = new int[3];
　　a[1] = new int[5];

　　对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。
　　而且，必须为每个数组元素单独分配空间。

　　例如：
　　String s[ ][ ] = new String[2][ ];
　　s[0]= new String[2];//为最高维分配引用空间
　　s[1]= new String[2]; //为最高维分配引用空间
　　s[0][0]= new String("Good");// 为每个数组元素单独分配空间
　　s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
　　s[1][0]= new String("to");// 为每个数组元素单独分配空间
　　s[1][1]= new String("You");// 为每个数组元素单独分配空间

　　3．二维数组元素的引用
　　
　　对二维数组中的每个元素，引用方式为：arrayName[index1][index2]
　　例如： num[1][0]; 
   4．二维数组举例：

　　【例2．2】两个矩阵相乘
　　public class MatrixMultiply{
　　　public static void main(String args[]){
　　　int i,j,k;
　　　int a[][]=new int [2][3]; //动态初始化一个二维数组
　　　int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化
　　　　　　　　　　　　　　　　　　　　　　　　　　 一个二维数组
　　　int c[][]=new int[2][4]; //动态初始化一个二维数组
　　　for (i=0;i<2;i++)
　　　　　for (j=0; j<3 ;j++)
　　　　　　a[i][j]=(i+1)*(j+2);
　　　for (i=0;i<2;i++){
　　　　　for (j=0;j<4;j++){
　　　　　　c[i][j]=0;
　　　for(k=0;k<3;k++)
　　　　　c[i][j]+=a[i][k]*b[k][j];
　　　　　　}
　　　　　}
　　　System.out.println("*******Matrix C********");//打印Matrix C标记
　　　for(i=0;i<2;i++){
　　　　　for (j=0;j<4;j++)
　　　　　　System.out.println(c[i][j]+" ");
　　　　　System.out.println();
　　　　　　}
　　　　　}
　　　}

　　2．5 字符串的处理

★ 字符串的表示

　　Java语言中，把字符串作为对象来处理，类String和StringBuffer都可以用来表示一个字符串。(类名都是大写字母打头)

　　1．字符串常量

　　字符串常量是用双引号括住的一串字符。
　　　　"Hello World!"

　　2．String表示字符串常量

　　用String表示字符串：
　　String( char chars[ ] );
　　String( char chars[ ], int startIndex, int numChars );
　　String( byte ascii[ ], int hiByte );
　　String( byte ascii[ ], int hiByte, int startIndex, int numChars );
　　String使用示例：
　　String s=new String() ; 生成一个空串

　　下面用不同方法生成字符串"abc"：
　　char chars1[]={''a'',''b'',''c''};
　　char chars2[]={''a'',''b'',''c'',''d'',''e''};
　　String s1=new String(chars1);
　　String s2=new String(chars2,0,3);
　　byte ascii1[]={97,98,99};
　　byte ascii2[]={97,98,99,100,101};
　　String s3=new String(ascii1,0);
　　String s4=new String(ascii2,0,0,3);
3．用StringBuffer表示字符串

　　StringBuffer( ); /*分配16个字符的缓冲区*/
　　StringBuffer( int len ); /*分配len个字符的缓冲区*/
　　StringBuffer( String s ); /*除了按照s的大小分配空间外,再分配16个
　　　　　　　　　　　　　　　字符的缓冲区*/

★访问字符串

　　 1．类String中提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。

　　◇ public int length() 此方法返回字符串的字符个数
　　◇ public char charAt(int index) 此方法返回字符串中index位置上的字符，其中index 值的 范围是0~length-1
　　◇ public int indexOf(int ch)
　　 　public lastIndexOf(in ch)
　　
　　返回字符ch在字符串中出现的第一个和最后一个的位置
　　◇ public int indexOf(String str)
　　　 public int lastIndexOf(String str)
　　返回子串str中第一个字符在字符串中出现的第一个和最后一个的位置
　　◇ public int indexOf(int ch,int fromIndex)
　　　 public lastIndexOf(in ch ,int fromIndex)
　　返回字符ch在字符串中位置fromIndex以后出现的第一个和最后一个的位置
　　◇ public int indexOf(String str,int fromIndex)
　　　 public int lastIndexOf(String str,int fromIndex)
　　返回子串str中的第一个字符在字符串中位置fromIndex后出现的第一个和最后一个的位置。
　　◇ public void getchars(int srcbegin,int end ,char buf[],int dstbegin)
　　 srcbegin 为要提取的第一个字符在源串中的位置， end为要提取的最后一个字符在源串中的位置，字符数组buf[]存放目的字符串，　　　 dstbegin 为提取的字符串在目的串中的起始位置。
　　◇public void getBytes(int srcBegin, int srcEnd,byte[] dst, int dstBegin)
　　参数及用法同上，只是串中的字符均用8位表示。

　　2．类StringBuffer提供了 length( )、charAt( )、getChars( )、capacity()等方法。

　　方法capacity()用来得到字符串缓冲区的容量，它与方法length()所返回的值通常是不同的。
 
★修改字符串
修改字符串的目的是为了得到新的字符串，类String和类StringBuffer都提供了相应的方法。有关各个方法的使用，参考java 2 API。

　　1．String类提供的方法：

　　　concat( )
　　　replace( )
　　　substring( )
　　　toLowerCase( )
　　　toUpperCase( )

　　◇ public String contat(String str);
　　用来将当前字符串对象与给定字符串str连接起来。
　　◇ public String replace(char oldChar,char newChar);
　　用来把串中出现的所有特定字符替换成指定字符以生成新串。
　　◇ public String substring(int beginIndex)；
　　public String substring(int beginIndex,int endIndex);
　　用来得到字符串中指定范围内的子串。
　　◇ public String toLowerCase();
　　把串中所有的字符变成小写。
　　◇ public String toUpperCase();
　　把串中所有的字符变成大写。

　　2．StringBuffer类提供的方法：

　　append( )
　　insert( )
　　setCharAt( )

　　如果操作后的字符超出已分配的缓冲区,则系统会自动为它分配额外的空间。
　　◇ public synchronized StringBuffer append(String str);
　　用来在已有字符串末尾添加一个字符串str。
　　◇ public synchronized StringBuffer insert(int offset, String str);
　　用来在字符串的索引offset位置处插入字符串str。
　　◇ public synchronized void setCharAt(int index,char ch);
　　用来设置指定索引index位置的字符值。

　　注意：String中对字符串的操作不是对源操作串对象本身进行的，而是对新生成的一个源操作串对象的拷贝进行的，其操作的结果不影响源串。

　　相反，StringBuffer中对字符串的连接操作是对源串本身进行的，操作之后源串的值发生了变化，变成连接后的串。

★ 其它操作

　　 1．字符串的比较

　　String中提供的方法：
　　equals( )和equalsIgnoreCase( )
　　它们与运算符''= =''实现的比较是不同的。运算符''= =''比较两个对象是否引用同一个实例，而equals( )和equalsIgnoreCase( )则比较　　两个字符串中对应的每个字符值是否相同。

　　2．字符串的转化

　　java.lang.Object中提供了方法toString( )把对象转化为字符串。

　　3．字符串"+"操作

　　运算符''+''可用来实现字符串的连接：
　　String s = "He is "+age+" years old.";
　　其他类型的数据与字符串进行"+"运算时，将自动转换成字符串。具体过程如下：
　　String s=new StringBuffer("he is").append(age).append("years old").toString();

　　注意：除了对运算符"+"进行了重载外，java不支持其它运算符的重载。   

文章出处：DIY部落(http://www.diybl.com/course/3_program/java/javajs/200847/108479_2.html)

文章出处：DIY部落(http://www.diybl.com/course/3_program/java/javajs/200847/108479.html)

public class exp{
 public static void main(String[] args){
  double x = 11.635;
  double y = 2.76;
  System.out.println("the value of e is " + Math.E);
  System.out.println("exp(" + x + ") is " + Math.exp(x));
  System.out.println("log(" +x+ ") is " + Math.log(x));

  System.out.println("pow(" +x+ "," +y+ ") is" + Math.pow(x,y));
  System.out.println("sqrt(" +x+ ") is " + Math.sqrt(x));
 }
}

         Java Studio 和 NetBeans IDE如出一辙，原本 Java Studio 也是在 NetBeans 的基础上开发的，所以，卸了Studio，开始深入学习 NetBeans。

         下面介绍如何使用 NetBeans 写 Applet。

         一、创建或导入applet文件：

    1.      选择“文件”

<font size="3">&gt;</font>“新建项目”(Ctrl-Shift-N)。在“类别”下选择“常规”。

    2.      选择以下选项之一：
            如果要创建新的 Applet 源文件，请在“项目”下选择“Java 类库”。单击“下一步”。
            如果要导入 Applet 源文件，请选择“包含现有源的 Java 项目”。单击“下一步”。在“源包文件夹”文本框中指定文件的位置 。

    3.      在“项目名称”下键入 HelloApplet。将“项目位置”更改为计算机中的项目存储位置。

    4.      单击“完成”。如果导入了 Applet 源文件，直接参考下面部分的运行和调试。

    二、创建applet源文件：

    1.      在“项目”窗口中，右键单击 HelloApplet 项目节点，然后选择“新建文件/文件夹”(Ctrl-N)。

    2.      在“类别”下选择“Java 类”。在“文件类型”下选择 \"Applet\"。单击“下一步”。

    3.      在“类名”下键入 myApplet。在“包”下键入 ncut.zyf.hello。

    4.      单击“完成”。IDE 会在指定的包中创建 Applet 源文件。将在源编辑器中打开 Applet 源文件。

    5.      复制并粘贴以下代码来覆盖现有的缺省代码，以定义 Applet 类：

    package ncut.zyf.hello;

    import java.applet.Applet;

    import java.awt.Graphics;

         public class myApplet extends Applet {
             public String s;
             public void init() {
      s = getParameter(\"s\");
      if (s == null)  s = \"nothing\";
     }
             public void paint(Graphics g) {
                 g.drawString(s,100,100);
          g.drawString(\"Hello applet!\", 50, 25); [Page]
             }
         }

    三、生成和运行applet源文件：

    1.      在“项目”窗口中右键单击 HelloApplet 项目节点，然后从上下文菜单中选择“生成项目”。

    2.      将在dist文件夹中创建 HelloApplet.jar 文件。

        在“项目”窗口中右键单击 Applet 类节点，然后从上下文菜单中选择“运行文件”。将在 build 文件夹中创建嵌入了 Applet 的myApplet.html 启动程序文件，并在 Applet 查看器中启动该文件。

    四、通过修改参数来调试applet源文件：

    1.      打开“文件”窗口 (Ctrl-2)。

    2.      将myApplet.html 启动程序文件从 build 文件夹复制到 Applet 类位于src 文件夹的包中（在本例中应复制到nuct.zyf.hello）。请确保 myApplet.html 启动程序文件与 Applet 类具有相同的名称。

    3.      现在根据需要编辑myApplet.html启动程序文件。 在生成项目时,myApplet.html启动程序文件将从 src 文件夹复制到 build 文件夹中。

    五、在 web 应用程序中嵌入 applet：

    1. 创建 web 项目：    选择“文件”

<font size="3">&gt;</font>“新建项目”。在“类别”下选择 \"Web\"。在“项目”下选择“Web 应用程序”。单击“下一步”。  在“项目名称”下键入 HelloWebApplet。将“项目位置”更改为计算机中的任意文件夹。 单击“完成”。

    2. 将applet JAR 文件添加到项目中：如果要在 Web 项目中包括 Applet JAR 文件，可以通过添加包含 JAR 文件的 NetBeans IDE 4.1 Java 项目，或者通过添加 JAR 文件自身来执行此操作。在 NetBeans IDE 4.1 Java 项目中修改 Applet 时，只要生成 Web 项目，IDE 都会生成新的 Applet 版本。1.      在“项目”窗口中，右键单击 HelloWebApplet 项目节点，然后从上下文菜单中选择“属性”。

一、     编译器的选择。

毋庸置疑，学习Java需要一个编译器，至于是命令行和IDE（集成开发环境）则凭用户自身而言，许多高手喜欢用命令行中敲下命令，然后用vim来编辑，不可否认，这样很好，而且如果是linux下面的没有图形界面的话，这个似乎还是唯一的办法，本人现在也正在学习linux，有时候也有种恨不得一直都用vim和命令来工作的冲动，不过小弟才疏学浅，所以常常遇到问题，无奈又转回图形界面的拥抱。不过IDE的好处是众所周知的，用户界面的产生，确实是极大的方便了我们的工作，虽然掌握IDE的各种功能需要一定的时间，不过这个牺牲还是值得的，我认为IDE的好处就是可以省去很多麻烦，比如今天我遇到的，多文件的java的编译，在IDE中，没有任何问题，因为NetBeans中有项目管理，其中做到的工作我不知道，不过如果在命令行中用javac和java命令的话，就还是有各种奇怪的错误，各位看到这篇帖子，如果不吝赐教的话，不妨留下言，告诉我如果在命令行下实现多java文件的编译。我知道在Netbeans中，有包的管理，所以在一个包下面，我写的每一个类，其实都可以通用，所以就可以自然的实现各个文件直接调用，就像在C++中，我声明文件在.h文件中，而实现可以放在几个.cpp文件中，java不需要，只需要把这些java文件放在一个包下面，这样就在其他的java文件中，只要直接调用就可以了，而没有相应的麻烦，不过这个是IDE中的操纵，具体的命令行，我觉得多少还有些吃力不讨好，何况现在我还是个菜鸟呢！

另外，对于初学者下面这个或许有用。

1.     Java程序为何可以实现跨平台呢？因为JVM（Java Virtual Machine）的存在，具体来说说java程序的生成机制吧。首先，用户的.java程序，经过编译器（命令行中是javac）的编译，生成.class文件，而这个文件不是能够直接执行的，是一个二进制文件，它需要JVM进行解释执行，这里，解释执行和编译执行时程序执行的两种不同方式。所谓编译执行，就是本机代码经过编译连接之后，在本机形成一个文件，而这个文件的运行，一旦开始，就跟编译器和其他工具无关，具有独立性，可以自己执行。而解释执行呢，就是需要解释器（java）来一句一句的执行，解释一句，执行一句，所以可想而知，编译执行的效率要更高一些，而且由于java中JVM的存在，所以将class文件解释执行，中间的过程可想，速度会慢很多，虽然Sun声称什么高效或者其他，鄙人确实不敢苟同。一个程序的执行跟跑破机子一样，完全没有优越性而言，不过这里那个可移植性，可是很受业界的欢迎的！最后说一句，JVM决定了java程序的可移植性，所以一个系统如果不支持JVM，那么自然不要指望java程序可以移植到这个上面。理解了这个，其实也就知道了这个可移植性的本质了。由于主流系统，windows，linux，unix，Mac都支持，所以就可想其应用之广泛了。注意，JVM模拟的是一个硬件系统，包括指令系统，内存管理……所以虚拟机的概念要清楚。

2.     安装IDE。

注意在进行所有的工作之前，需要做的是先下载jdk，从sun的网站上下载最新的jdk，然后安装之后，你的机子上面才算装了JVM，这个时候，默认会为你的系统环境变量设置好它最近的路径。检查的办法很简单，进入命令行，输入javac命令，如果出现了帮助列表，那么说明配置好了，否则就要手动设置了，这里不详细讲解了，读者从网上可以看到巨多。而此时，你可以在命令行中直接工作了，比如进入一个目录，然后创建java源程序，同时在确保是该目录下用javac编译，生成class文件，然后用java命令执行相应的class文件，注意不要.class后缀名了。OK。

         这里要说的是IDE的按照，所以呢，我们需要选择一个IDE，比较好的当然是NetBeans和Eclipse，但是在安装之前，还是需要装前面介绍的jdk，为何，因为这些软件也是基于JVM的，所以如果没有JVM，那么就不会顺利安装，更不可能用了。当然，如果你没有装好的，安装过程也会提示的。不过何必呢。正是因为这个机制，所以NetBeans的启动慢如蜗牛，Eclipse也好不了多少，这个也是为何我如此厌恶的原因，当然，启动之后 就好多了，所以不要常关闭，否则开启的时候还是会等很久的。相比而言，VS 2005就好多了，看了MS的人也不是吃白饭的。当然，本来都不是同一个东西，所以没有可比性，不然高手们又要笑话我了。不过Java的这个缺陷，总是让我有点不平。凭借着强大的类库，我看到了一个新的简单易学，却功能强大的新工具，想比较C++而言，我只能说自己遇到Java太晚了，如果早点碰到Java，或许我可以早点做到很多很好玩的东西，不过不废话了，总之，觉得这个也是Java难以跨越的鸿沟吧，但愿可以更进一步优化吧！

《未完待续》

                                    -------------------------------各位和我一起学Java吧！