javaSE_1

 

java工具类：

java  BeanCodeGenerator  aa.java  （SetterGetter 疯狂JAVA版）

 

重写equals方法  DEMO2

 

 

文字编辑器设计 C#版

文字编辑器设计 JAVA版

图片管理器

 

 

负数在计算机里以 补码 存在 （正数的补码和原码相同，也就是以原码的形式存在）

负数 转为 补码 （

原码符号位外取反得到反码

反码加1得到补码

 ）

 

左移运算符： <<

整体左移指定位数，右边空出来的位以0来补充（左边移出去的被去除）

右移运算符： >>

右移指定位数后，左边空出来的位以原来的符号位来填充（原来是正数，则补0；原来 是负数则补1）（右移出去的被去除）

无符号右移运算符： >>> （这个C语言里好像没有，java有）

右移指定位数后，左边空出来的位以0来填充（右移出去的被去除）

 

Java移位运算符规则：

对于低于int类型的（byte/shor/char）操作数总是先自动转换为int类型后再移位

对于int类型的移位a>>b，当b>32，系统先用b对32求余（因为int类型只有32位），得到的结果才是真正移位的位数。例如a>>33和a>>1的结果完全一样，而a>>32的结果和a相同

对于long型的整数移位时a>>b，当b>64，与上面的规则一样。

 

左移n位 相当于 乘以2的n次方

右移，则是除以2的n次方

进行位移运算不会改变操作数本身，它只是得到了一个新的运算结果，而原来的操作数本身是不会改变的。

 

逻辑运算符：

&&  与

&   不短路与，作用与&&相同，但不会短路

||       或

|        不短路或，作用与||相同，但不会短路  [W1] 

！     非    

^       或与 （当两个操作数不同时才返回true ，两操作数相同时返回false）

 

 

开发注意事项：

 

if (a>0){

    a++;

}

else{

    b++;

}                 //要加上大括号，防止后来的bug

 

 

Java程序里创建对象的4个常规方式如下：

         通过new 调用构造器创建java对象

         通过class对象的newInstance()方法调用构造器创建

         通过java 的反序列化机制从IO流中恢复java对象

         通过java对象提供的clone()方法复制一个新的

此外，可以以直接量的方式创建java对象，  String str = “abc”

此外，也可以通过简单的算法表达式，连接运算来创建java对象  String str2 = “abc” + “xyz”

数组.....

 

可变参数：  [W2] 

DEMO

缓存和集群

使用缓存前提：   缓存本质就是牺牲空间，换取时间

1.内存够

2.缓存数据量要可控

3.数据的读操作频繁，但写操作较少

4.系统允许部分“脏数据”

缓存设计过程中，重要的指标：命中率

 

运用内部类 [W3] 

匿名类  DEMO

 

GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：

System.gc()

Runtime.getRuntime().gc()

 

内存管理： (分配 + 回收)

       JVM在何时决定回收一个java对象所占据的内存 ？

         JVM会不会漏掉回收某些java对象，使之造成内存泄漏 ？

         JVM回收java对象所占用内存的实现细节 ？

         JVM能否对不同java对象占用的内存区分对待、回收 ？

         常见垃圾回收机制的实现细节 ？

yound

old

Permanent (永生代，默认64K)

 

         只要有引用变量引用此对象，垃圾机制就不会回收它

         垃圾回收机制采用有向图的方式来管理内存的，即从main节点开始， 具有较高的精度，但效率较低。

        

         上面的图，考虑到static ，所以多了一个可恢复状态，应该是这样 （疯狂讲义）

 

         从JDK1.2开始，j ava.lang.ref包下提供了3个类：SoftReference/PhantomReference/WeakReference。

         它们分别代表了系统对对象的3种引用方式：软引用，虚引用，弱引用。、]

         归纳起来，java语言对对象的引用有如下4种：

                   强引用StrongReference (一般的new，这种最容易造成内存泄漏)

软引用SoftReference通过SoftReference类实现   DEMO创建1000个Person对象

         当一个对象只具有软引用时，它有可能被垃圾机制回收。对于只有软引用的对象，当系统有足够的内存空间时，它不会被系统回收；当内存不足时，系统将会回收它 (通常用于对内存敏感的系统中)

弱引用 WeakReference 比软引用的引用级别更低，不管系统内存是否足够的  DEMO

虚引用 PhantomReference 完全类似于没有引用，主要用于跟踪对象被垃圾回收的状态，虚引用不能单独使用，必须和引用队列（ReferenceQueue）联合使用  DEMO

引用队列由java.lang.ref.ReferenceQueue类表示，它用于保存被回收后对象的引用。当把软引用、弱引用和引用队列联合使用时，系统在回收被引用的对象之后，将把被回收对象对应的引用添加到关联的引用队列中。   与软引用、弱引用不同的是，虚引用在对象被释放之前，将把它对应的虚引用添加到它关联的引用队列中，这使得可以在对象被回收之前采取行动

        

         Runtime.getRuntime().runFinalization() ;   //System. runFinalization()

//强制垃圾回收机制调用系统中去活对象的finalize方法

      

java –Xmx1024m MemoryTest

String和StringBuffer           ( Str1 + str2 ).intern()  

二维数组比一维数组占用更多内存空间

哈希表进行内存中的数据搜索 [W4]  hashmap

用arrayCopy()提高数组截取速度 [W5] 

Foreach  [W6] 

位运算，++

Import static   DEMO

位运算，提高程序效率实例： int占有4个字节：00000000 00000000 00000000 00000000

              判断用户输入是否为奇数

              XOR字符加密例子

              2次方运算示范

 

尽量使用Stack(栈)方法内部的局部变量

 

垃圾回收机制：[W7]         回收实例A     回收实例B

在JAVA中没有析构函数，但有Finalize() 在回收前执行，它被声明为protected。

只是不知道什么时候执行，但会自动执行，可以设置它的清除动作。

（如果确定不再使用某个对象，可以在参考到此对象的名称上指定null，表示这个名称不再参考至任何对象，不被任何名称参考的对象将会被回收资源。可以使用System.gc()建议程序进行垃圾回集，如果建议被采纳，则对象资源会被回收，回收前会执行Finalize()。）

 

提高运行效率（安全性）
PHP	JAVA
ZendOpmind,pear等 JSON数据格式 索引/存储过程/事务/全文搜索 [W8]  mysql缓存查询 [W9]   sqlserver缓存依赖 多线程 并发控制 加锁 解锁 精简代码 (位运算，++) (界面尺寸，CSS样式表的优化) 使用索引查询 [W10]  聚集索引 索引视图(sql server )、全文索引[W11] 、XML索引（sql server ）	存储过程/事务/ 数据库连接池   多线程 精简代码
自动加载对象： _autoload();   /javascript

 

 

JAVA调试： 命令行：java -? 查看Java命令帮助

读取内存信息函数       MemoryTest

1．Runtime.getRuntime().maxMemory()

得到虚拟机可以控制的最大内存数量。

2．Runtime.getRuntime().totalMemory()

得到虚拟机当前已使用的内存数量。

Java虚拟机在默认的情况下只能控制66650112 byte即63.56MB内存。

CMD命令          ：     java -Xmx1024m –classpath [W12] 

测试

long start=System.currentTimeMillis(); //取得当前时间

long get=System.currentTimeMillis();  //取得当前时间

System.out.println("总用时间:"+(get-start)+"ms");

 

 

异常处理：

 

当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

 

try { }

catch( e ) { alert(  )};

[finally{   }]

可控式异常[X13] （checked exception）（编译异常）（检查性异常） 可预期会发生的，编译器要求你必须处理的

java.lang.exception

执行时异常（runtime exception） （非可控式异常）（运行期异常）发生在程序执行期间，不一定可预测发生，编译器不要求一定处理

java.lang.RuntimeException

错误

java.lang.Error

 

在出现异常的地方，就终止执行代码，然后进入catch

如果有多个catch语句，则进入匹配异常那个catch

 

Finally不一定会执行  System.exit

 

自定义异常类

Entends Exception

抛出异常只能比父类的少、不能比父类的多s

[W14] 

程序应该使用如下的结构的代码实现   DEMO

 

 

抛出异常：throw语句

异常的继承架构：

JAVA所处理的异常主要分为两大类：

严重的错误：Error类用其子类

非严重的错误：Exception及其子类

都继承自Throwable类，Throwable类拥有几个取得相关异常信息的方法

getLocalizedMessage() 取得异常对象的信息化描述

getMessage()                         取得异常对象的信息描述

PrintStackTrace()                   显示异常的堆栈信息

 

JAVA中用2种方法处理异常：

1.在发生异常的地方直接处理

2.将异常抛给调用者，让调用者处理

 

一些重要异常的继承架构：

Throwable

Error（严重的系统错误）

LinkageError

ThreadDeath

VirtualMachineError

...

Exception

ClassNotFoundException

CloneNotSupportedExcetion

IllegalAccessException

...

RuntimeException（执行时异常）

ArithmeticException

ArrayStoreExceotion

ClassCastException

 

捕捉异常对象时，如果父类异常对象在子类异常对象之前被捕捉，则catch子类异常对象的区域将永远不会被执行，事实上编译器也会帮你检查此错误       ExceptionDemo            掉转顺序后ExceptionDemo2[W15] 

 

 

jad 反编译

javap  深入了解编译器机制

-c 分解方法代码

-l 指定行号和局部变量列表

 

class Base{

private int i = 2 ;

public Base(){

this.display() ;

}

public void display(){

...

}

}

//经过编译器处理后，类对象的构造器就变为

public Base(){

int i = 2 ;

this.display() ;

}

 

 

 

           断言（断点调试）：AssertionDemo

              Assert x>=0: “dddddd” ;

               Java -source 1.4  –ea  ..    

              断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：

     javac -source 1.4 Test.java

 

              assert boolean-expression

              assert boolean-expression：information-expression [W16] 

 

              动态开启断言：

           ClassLoader.getSystemClassLoader().setDefaultAssertionStatus(true);

 

           决定如何让所需的断言是有意义的：

           static

           {

              boolean assertionEnabled = false;

              assert assertionEnabled = true;

              if(!assertionEnabled )

                     throw new RuntimeException("assertion disabled!");

              }

 

 

Junit测试：(测试驱动Test-Driven)     junit源文件

官方网站下载：         junit.org

单元测试 （Unit Test）

设置：       复制junit.jar文件; 设置classpath指向juint.jar

集成JUnit到JCreator中:

首先打开选项，在工具那一项，添加一个工具，选DOS命令，然后输入名字：JUnit

在参数那一行填上：java -cp %JUNIT_HOME%/junit.jar;. junit.textui.TestRunner $[CurClass]
前提是要配置好%JUNIT_HOME%这个环境路径。这里用的JUnit的字符界面，当然也可以用图形界面，把textui改为swingui就可以了。
实例类  单元测试实例

上例要先编译出一个class出来，才能进行测试这个class
         assertEquals()      断定你的预期值与实际返回的结果是否相同，如果不同，TestRunner会捕捉异常，

文字窗口：junit.textui.TestRunner.run(MathToolUnitTest.class);

Swing窗口：junit.swingui.TestRunner.run(MathToolUnitTest.class);

 

netbeans:

assertEquals(x,y)	测试x是否等于y,x和y要求是简单类型数值 或者必须为实现了equals方法的类
assertFalse(x)	测试x是否为false，x是一个布尔类型的值
assertTrue(x)
assertNull(x)	测试x是否为空，x是一个对象或者null
assertNotNull(x)
assertNull(x)
assertSame(x,y)	测试x和y是否相同
assertNotSame(x,y)

 

MyClass.java

MyClassTest.java

 

陶宝哥Junit教程： Xp思想的体现 敏捷思想

      3.8里使用的是反射机制，必须test开头

         4.0里使用的是@Test注释，可以tttest等开关

        

SetUp 和TearDown及断言方法

3.8    DEMO

4.0    DEMO

 

3.8系列第一个类都继承了一人叫做TestCase的类，而TestCase的父类是Assert类

4.x系列第一个可以不继承任何的类，但是仍然可以直接使用import static org.junit.Assert.*;

 

Junit4中测试用例的要求：

         测试用例类必须是public

         测试用例的测试方法应该是public

         测试用例的测试方法必须没有返回值

         测试用例的测试方法必须没有形参列表

 

 

注释Annotation：

         @Test                                    定义一个要测试的方法

         @Before                                测试用例的对象初始化时，在第一个测试之前都会被执行的方法，这个方法常用来进行一些测试环境的准备，比如说读入输入数据，

         @After                                  测试用例的对象销毁时，

@BeforeClass                       在所有的测试开始之前执行，这个方法在类运行的时候运行，而且只会运行一次，所以常用来做一些所有的方法都要依赖的工作，比如说，数据库的链接

         @AfterClass                         类被销毁时执行一次

         @Ignore                                可以忽略的测试 [W17] 

         @Test( expected  |  )       异常处理     3.8 DEMO  4.0 DEMO

                   @Test(expected = ArithmeticException.class)                //检查此方法是不是抛出了对应的异常

         @Test(timeout = 100)          要求测试必须在此100毫秒内

 

Failure 断言中出现预想值与实际值不同

Error断言前已经出错了

 

Junit和EasyMock框架进行单元测试   DEMO

模拟对象取代真实对象的位置，用于测试一些与真实对象进行交互或依赖于真实对象的功能

EasyMock.expect(calcMethodMock.calc(Position.BOSS)).andReturn(7000.00).times(2) ;

 

 

HttpUnit

测试1：测试网页是否存在

要测试一個网页是否存在，只要简单的通过WebConversation的getResponse()方法即可，例如：

WebConversation webConversation = new WebConversation();

webConversation.getResponse(

牋牋牋牋牋牋 "http://localhost:8080/httpUnit/");

如果找不到网页，則會引发HttpNotFoundException，由于不是断言错误，所以这会在JUnit中产生一個Error。

测试2：Get、Post

您可以分別使用GetMethodWebRequest或PostMethodWebRequest來发出Get或Post请求，例如：

WebConversation webConversation = new WebConversation();

WebRequest request =new GetMethodWebRequest("http://localhost:8080/httpUnit/");

WebResponse response =webConversation.getResponse(request);

要在请求中加上參數，可以使用setParamter()方法，例如：

request.setParameter("username","taobaoge");

测试3：取得表格信息

 

您可以从WebResponse中取得相关的HTML信息，假设网页中有如下这样的一个表格：

书籍名称	设计模式(Design Pattern)
软件版本	无
书籍版次	第二版
修改时间	2004/12/26

 

下面的程序演示如何取得表格相关信息进行测试：

WebConversation webConversation = new WebConversation();

WebResponse response = webConversation.getResponse("http://localhost:8080/httpUnit/tableTest.jsp");

WebTable webTable = response.getTables()[0];  //getForms()[0]

assertEquals(2, webTable.getColumnCount());

TableCell cell = webTable.getTableCell(2, 0);

assertEquals("书籍版次", cell.getText());

测试4：跟随超链接

网页中有很多的超链接，我们可以使用HttpUnit来模拟超链接的点击，例如网页中如果有个超链接如下：

<a href="httpUnitABC.jsp">HttpUnit ABC</a>

则可以使用下面的程序来吵到链接，然后模拟一个click动作来跟随这个超链接：

WebConversation webConversation = new WebConversation();

WebResponse response = webConversation.getResponse("http://localhost:8080/httpUnit/");

WebLink link = response.getLinkWith("HttpUnit ABC");

WebRequest clickRequest = link.getRequest();

WebResponse linkPage =webConversation.getResponse(clickRequest);

测试5：测试Cookie

如果被测试的网页需要Cookie信息，您可以使用WebConversation的addCookie()方法发送Cookie信息

给网页，例如：

WebConversation webConversation = new WebConversation();

webConversation.addCookie("user", "taobaoge");

WebResponse response = webConversation.getResponse("http://localhost:8080/httpUnit/");

如果网页中包含了Cookie，您可以使用getCookieValue()方法取得网页中包含的Cookie信息，若网页包括下面的Scriptlet：

<%

牋 Cookie cookie = new Cookie("customerId", "12345");

牋 response.addCookie(cookie);

%>

可使用下面的方式來测试传回的Cookie信息：

assertEquals("taobaoge",webConversation.getCookieValue("user"));

测试6：Authorization

如果您的网页中有预设的HTTP基本验证，则可以使用WebConversation的setAuthorization ()方法來设定验证信息，例如：

webConversation.setAuthorization("justin", "123456");

测试7：设定代理

有的時候，您测试的目的网页可能必须通过代理服务器才能连上，你可以通过设定系统属性来设定HttpUnit使用代理，例如：

System.getProperties().put("proxySet", "true");

System.getProperties().put("proxyHost", "proxy.ntu.edu.tw");

System.getProperties().put("proxyPort", "8080");

如此之來，HttpUnit就會通过指定的代理服务器來发送请求与接受相应。

 

TDD   Test Driven Development

TFD    Test First Development

 

Ant与junit结合测试：

建议直接将JUnit的junit.jar直接放置在Ant的lib目录下，并记得改变原先有关junit的Classpath的路径，

例如：重新指向%ANT_HOME%/lib/junit.jar（假设已经设置了ANT_HOME）

Ant使用<junit>标签来设置junit测试。实例 （printsummary会将测试结果简单地显示出来）

自动生成测试报告：

加入<formatter>标志设置即可

<target   >

  <junit  printsumary="yes">

    <formatter type="plain"  usefile="false" />

    <test    />

    <classpath    />

  <junit>

</target>

当usefile属性设置为true时，会自动将结果保存到文件中，默认为TEST-*.txt，*为测试案例类名称

 

<formatter type="XML"  usefile="false" />    将测试结果保存到report目录中，文件名称为  .xml。

 

<junitreport>标签使用XSLT将XML文件转换为HTML文件：

<target name="report" depends="test">

<junitreport  todir="${report.dir}">

<fileset dir="${report.dir}">

<include name="TEST-*.xml" />

</fileset>

<report format="frames" todir="${report.dir}/html" />

</junitreport >

</target>

<include>设置搜寻TEST-*.xml文件，将之转换为HTML文件，而结果保存在report/html目录下

format="frames" 表示HTML报告文件有边框

 

单元测试与Java Team开发的结合:
Java下的team开发，一般采用cvs(版本控制) + ant(项目管理) + junit(单元测试、集成测试)的模式：
每天早上上班，每个开发人员从 cvs server 获取一个整个项目的工作拷贝。
拿到自己的任务，先用 junit 写今天的任务的测试代码。
然后写今天任务的代码，运行测试（单元测试），直到测试通过。
任务完成在下班前一两个小时，各个开发人员把任务提交到cvs server。
然后由主管对整个项目运行自动测试（集成测试），哪个测试出错，就找相关人员修改，直到所有测试通过。

定义变量时指定的初始值和初始化中指定的初始值，与它们在源程序中的排列顺序相同

 

Int a = 5 ;

Int b = 6 ;

If (a>4 || b++>10)   //不会执行b++

If(a>4 | b++>10)           //尽管已经得到true了，但还会执行b++，不短路   

 

 

可变参数只能放在参数列表的最后；

位于变量类型和变量名之间，前后有无空格都无所谓；

在方法体中以数组的方式访问可变参数。

内部类给我们的最大的好处就是，能非常方便地访问到外部类的成员。

DEMO3

如果仅仅是为了数据存储，用普通数组是比较适合的，但是如果为了频繁查询的目的，HashMap是必然的选择。

 

普通数组查询例子

哈希表查询例子

Hashmap用法

 

for(int i=0;i<10000000;i++ ){

    System.arraycopy(oldArray,100,newArray,0,120);

   }

JDK6中，也为Arrays类新增了数组复制的copyOf()方法

Arrays.copyOf

只要是实现Collection接口的对象，都可以使用J2SE5.0以后增强的for循环功能

垃圾回收器只知道释放那些经由new 分配的内存

c#有析构方法

mysql数据库引擎：memory (数据存储在内存)

 

php mysql 缓存技术：       5.13. MySQL查询高速缓冲

   基本的缓存是用PHP的两个函数serialize()和unserialize()(译注：这二个函数分别代表序列化与反序列化)。

   php+mysql缓存技术的实现

 

SELECT SQL_CACHE id, name FROM customer;

SELECT SQL_NO_CACHE id, name FROM customer;

 

 

sqlserver 缓存技术：  

注意     DBCC   PINTABLE   可以提供性能改进，但是使用时务必小心。如果驻留大表，则该表在开始时会使用一大部分高速缓存，而不为系统中的其它表保留足够的高速缓存。如果所驻留的表 比高速缓存大，则该表会填满整个高速缓存。sysadmin   固定服务器角色的某个成员必须关闭而后重新启动   SQL   Server，然后使表不驻留。驻留太多的表和驻留比高速缓存大的表会产生同样的问题。 

 

oracle缓存技术：

在oracle里，建table的时候，可以用带cache 的命令，把表放在buffter cache 里，在查询该表的时候就可以直接从buffer cache里读取，而不需要再从磁盘里读，从而加快查询的速度。   

使用索引查询
Select * FROM IndexTestTable WITH(INDEX(icIndexTestTable))
 Where Status='B'

sqlserver调用全文索引

select top 1000 * from news where contains(title ,'"*M*"')

普通查询

select top 1000 * from news where title like '%M%'

 

mysql调用全文索引

CREATE TABLE articles (
　　->　 id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
　　->　 title VARCHAR(200),
　　->　 body TEXT,
　　->　 FULLTEXT (title,body)
　　-> );

SELECT * FROM articles
　　->　　　　　WHERE MATCH (title,body) AGAINST ('database');

 

//全文索引在 MySQL 中是一个FULLTEXT类型索引。FULLTEXT索引用于MyISAM表，可以在CREATE TABLE时或之后使用ALTER TABLE或CREATE INDEX在CHAR、VARCHAR或TEXT列上创建。

将数据装载到一个已经有FULLTEXT索引的表中，将是非常慢的。

 

 

java –mx1024m MemoryTest

这种异常好像只有JAVA有

程序不应该把底层的异常传到用户界面，原因如下二：

  不想看到，没任何帮助，不友好

  暴露出来 来安全

 

程序应该先捕获原始的异常，然后抛出一个新的业务异常，新的业务异常中包含了用户的提示信息，这种处理方式被称为异常转译

 

Exception异常对象的捕捉编写在最后，以便捕捉到所有你所尚没考虑到的的异常

如果 是fault，则会发生java.lang.AssertionError异常

测试运行程序将不运行这些测试，但是它会指出这些测试被跳过了。

 

但是一定要小心。最初编写这些测试可能有一定的原因。如果永远忽略这些测试，那么它们期望测试的代码可能会中断，并且这样的中断可能不能被检测到。忽略测试只是一个权宜之计，不是任何问题的真正解决方案。

 

 

 

 

 

Java语言规定标识符是以字母、下划线"_"或美元符号"$"开始，随后可跟数字、字母、下划线或美元符号的字符序列。

 

 

import java.util.*   [W1] 

静态导入 import static   导入指定类的单个静态属性或全部静态属性

 

loop:

...for()..

break loop;

 

42.3 % 10  [W2] 

-×××%××× [W3] 

10%10 [W4] 

 

数组定义：[W5] 

int intergerexample[10] ;

float floatSample[] = new float[10] ;

int []trueJava = new int[3] ;

int []intergerexample = {1,2,3,4} ;

 

为多维数组分配内存时，只需要为第一维指定大小和分配内存（与C语言相反），而其余维可以单独分配[W6] 

 

int[][][] a1 = new int[2][2][4];

int[][][] a2 = new int[2][][];

创建数组，对各种元素的默认赋值

boolean: false

byte: 0

char: '/u000'

short: 0

int: 0

long: 0L

float: 0.0f;

double: 0.0(D)

 

复制数组的方法：

1.for()遍历 [W7] 

2.System.arraycopy(arr1,0,arr2,0,arr1.length)

3.JDK6中，也为Arrays类新增了数组复制的copyOf()方法

Array.asList()此方法用于输出数组中的所有数 [W8] 

使用Arrays.binarySearch()执行快速查找。 [W9]  SE6新增功能

Arrays.copyOf()用法,这个方法是将原数组快速复制成一个新数组。如果新数组的长度小于旧数组的长度，将截取一部分旧数组中的元素，复制给新数组，反之，如果大于旧数组的长度，则将以0，null，或false给予补充。

实例1       实例2

Arrays.copyOfRange()用法，这个方法与前面介绍的Arrays.copyOf()的用法相似 [W10] 

 

deepEquals 、deepToString实例

 

二分法查找 算法 DEMO

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------

排序数组：

选择排序，昌泡排序，快速排序[W11] 

 

韩顺平分类：  DEMO

内部排序【交换式排序法（昌泡排序Bubble Sort，快速排序Quick Sort），选择式排序法（选择排序，堆排序），插入式排序法（插入排序，谢耳排序，二叉树排序）】

外部排序【合并排序法，直接合并排序法】

 

一般数据处理工作25%的时间都在进行排序

 

 

对象：

student astudent = new student();

student bstudent;

...

bstudent = astudent;  [W12] 

 

 

 

switch()

case [W13] 

..

defalut [W14] 

 

不应该这样写，安全性问题

等于2.3

等于负数

0

 

JAVA把它们当作对象来实现；

PHP，jsscript 等可以是不同类型的，但JAVA数组只是由若干个不同类型的变量组成

 

arr[0].lengh  //该行拥有的元素

arr.lengh    //拥有的行数

 

int intergerexample[][] = new int [3][];

intergerexample[0] = new  int[4];

//数组不赋值是默认：0 或 flase

for(int element:arr)    //数组arr[]

System.out.println(Arrays.asList(A));

Arrays.deepToString() 了将多维数组转换为字符串而设计的

 

Arrays.sort(a);

int index1 = Arrays.binarySearch(a, "f");

注意：不要对未排序的数组使用binarySearch();   二元搜索，

而一般用的是线性搜索，二元搜索要快得多

b = Arrays.copyOfRange(a, 2, 4);

 

最好的，但不稳定

如：java.lang.arrays类的sort方法

astudent ,bstudent引用相同的对象，但两变量没有关系

case 后可以是''字符，但不可以是""字符串

defalut 可以放到case 的前面

 

 

 

 

 

 

 

数据类型(都不支持无符号整数，但C语言.net支持)
	PHP	JAVA
整数类型	interger  //可以八进制，十六进制	字节型  byte占位：8 [W1]  短整型  short 占位：16 占2字节 整型    int   占位：32 占4字节 长整型  long  占位：64 [W2] 占8字节
浮点类型	浮点型：float 倍浮点型：double	单精度浮点型  float 占位：32 双精度浮点型  double 占位：6[W3] 4
字符类型		Character类 字符型  char  占位：16 [W4]
StringBuilder类 StringBuffer类 字符串类型	string	字符串 string  " " [W5]  作为一个对象
布尔类型	boolean	布尔型 boolean 占位：8
	数组  array 对象  object 资源  resource NULL	数组s 对象

JAVA数值的存储范围测试

 

 

 

 

 

 

表达式的数据类型自动提升：

1．所有的byte型，short型和char的值将被提升到int型；

2．如果一个操作数是long型，计算结果就是long型；

3. 如果一个操作数是float型，计算结果就是float型

4. 如果一个操作数是double型，计算结果就是double型

 

 

 

javasrcipt 支持4种数据类型：

对象(object)  数字(number)  字符串(string)  布尔值(boolean)

 

 

注释
JAVA	// 单行C++风格 /*   */  多行C风格 /**  */   [W6]
PHP	// /*   */ #   单行shell风格（Pell）
Javasrcipt	// [W7]  /*   */
Html	<!--  -->
CSS	/* */
jsp	输出注释       隐藏注释 <!--  -->             <%--         --%> <%@ page info="this is a page" %> <%=getServletInfo()%>
.net	<%--         --%>

 

 

用toString方法转换成String类型

String x = "a" + 4 + "c";编译时等效于：

String x = new StringBuffer().append("a").append(4).append("c");

 

String s1 = "hello";       String s2 = "hello";  两个指向同一个对象

String s1 = new String("Hello");   String s2 = new String("Hello");           不是指向同一个对象

 

 

for(int i=0;i<100;i++)

{

builder.append(i);   //效率比string高

}

StringBuilder类：单机非线程，没有处理同步问题，1.5后的新增类

StringBuffer类：多线程下用 [W8] 

//方法有：

append();

insert();

reverse();

replace();

setCharAt();

Capacity();  //返回的是字符串缓冲区的容量

setLength();

 

 

字节型  -128~127

短整型  -32768~32767

整型    -2147483648~2147483647

长整型 

 

byte与short混合运算，结果会是int类型

123L

默认为double,因为定义float要在数据后面加F，而double不用

float a;

a = 1.3;

这是不对的，因为高精度的不能赋给低精度的，1.3默认为double；

应该改为 a = 1.3f;

C语言是8位的，因为JAVA使用Unicode来表示字符，是全世界很多字符集的组合

string a = "abcd";   //jvm首先会在strings pool中通过equels 方法查找对象池中是否存放该String对象，如有，则返回已有的String对象给用户，如没有，jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings pool中。

string a = new string("abcd");   //jvm会马上在heap中创建一个String对象，然后将该对象的引用返回给用户。jvm是不会主动把该对象放到strings pool里面的，除非程序调用 String的intern方法

 

String str1 = new String("abc");      //jvm 在堆上创建一个String对象 

Stirng str2 = "abc";   //jvm 在strings pool中找不到值为“abc”的字符串，因此在堆上创建一个String对象，并将该对象的引用加入至strings pool中  此时堆上有两个String对象 

String str3 = "abc";

 //此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equels “abc” 因此直接返回str2指向的对象给str3，也就是说str2和str3是指向同一个对象的引用

/**  */  文档注释

允许使用javadoc实用工具程序来提取文档注释信息，并放到一个HTML

文件中

JavaScript还能识别HTML注释的开始部分"<!--"，JavaScript会将其看作为单行注释结束，如使用"//"一样。但JavaScript不能识别HTML注释的结果部分"-->"。

在JavaScript中，如果第一行以"<!--"开始，最后一行以"-->"结束，那么其间的程序就包含在一个完整的HTML注释中，会被不支持JavaScript的浏览器忽略掉，不能被显示。如果第一行以"<!--"开始，最后一行以"//-->"结束，JavaScript会将两行都忽略掉，而不会忽略这两行之间的部分。用这种方式可以针对那些无法理解JavaScript的浏览器而隐藏代码，而对那些可以理解JavaScript的浏览器则不必隐藏。

此类中的一些方法是同步的，当运行多线程时，确保类中的内容不被破坏

StringBuffer( ); /*分配16个字符的缓冲区*/ 

StringBuffer( int len ); /*分配len个字符的缓冲区*/ 

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