java日常小笔记

1、  JAR、WAR、EAR：

Jar文件（扩展名为. Jar，Java Archive）包含Java类的普通库、资源（resources）、辅助文件（auxiliaryfiles）等

War文件（扩展名为.War,WebArchive）包含全部Web应用程序。在这种情形下，一个Web应用程序被定义为单独的一组文件、类和资源，用户可以对jar文件进行封装，并把它作为小型服务程序（servlet）来访问。

Ear文件（扩展名为.Ear,EnterpriseArchive）包含全部企业应用程序。在这种情形下，一个企业应用程序被定义为多个jar文件、资源、类和Web应用程序的集合。

 

2、  自动类型转换

一个基本类型的值和字符串进行连接运算时，基本类型的值自动转换为字符串：

String  str2 = 3.5f +” ”;    输出：3.5

System.out.println(3+4+”Hello!”);     输出：7Helo!

System.out.println(“Hello”+3+4);      输出：Hello!34   （先把3当成字符串，再把4当成字符串）

当一个算数表达式中包含多个基本类型的值时，整个算术表达式的数据类型将会发生自动提升：所有的byte、short、char类型将会被提升到int类型；整个算数表达式的数据类型自动提升到与表达式中最高等级操作数相同的类型。操作数等级排序参考上图。

 

3、  反射优缺点

优点：

（1）能够运行时动态获取类的实例，大大提高系统的灵活性和扩展性。

（2）与Java动态编译相结合，可以实现无比强大的功能

缺点：

（1）使用反射的性能较低

（2）使用反射相对来说不安全

（3）破坏了类的封装性，可以通过反射获取这个类的私有方法和属性

 

4、  数组、链表、哈希表的创建，删除和查找用时比较

哈希表平均创建时间最长，但是插入、删除和查找平均用时最少。

数组创建用时最少，但是插入、删除操作时用时最多，查找时用时也比哈希表多，仅次于链表。

链表除了查找用时最大，其余都排在数组和哈希表之间。

由此可知：

数组的优势在于创建用时小，比较适合规模较小的数据。

链表创建时间快，但是要花很多时间来出插入删除，并且去链表查东西比较耗时。

哈希表在插入、删除、查找上都非常快捷。但是，超长的创建时间还是要慎重考虑。

 

5、  java中对象实例化的几种途径

1、直接new：代码比较直观，但是程序会出现耦合

2、程序出现接口，如果一个接口的子类直接通过new实例化，会出现耦合，所以使用工厂进行解耦合。

3、对象的克隆，将对象拷贝一份，但是需要在对象中覆写clone（）方法。

4、class类，通过class来实例化一个对象，通过一个字符串操作来完成。

 

6、  java用map解析JSON格式字符串：

         publicstatic Map jsonToMap(String jsonStr){

                   JSONObjectobject = null;

                   try{

                            object= JSONObject.fromObject(jsonStr);

                   }catch(Exceptione){

                            e.printStackTrace();

                   }

                   Iteratoriter = object.keyset().iterator();

                   Mapmap = new HashMap();

                   while(iter.hasNext()){

                            Stringkey = (String) iter.next();

                            Stringvalue = object.getString(key);

                            map.put(key,value);

                   }

                   returnmap;

         }

 

7、  使用双重锁判定可以大幅降低锁的征用。

classObjInstance{

                   //单例

         private static ObjInstance oi = newObjInstance();

         private static User user;

         private ObjInstance(){}

         public static User getUserInstance(){

                   if(user == null){

                            synchronized(oi){

                                     if(user ==null){

                                               user= new User(1,”hehe”);

                                               }

                                     }

                   }

return user;                        }

 

8、  hibernate的session事务管理：

public class NewsManager{

                   Public static voidmain(String[] args) throws Exception{

                            //实例化configuration(configure()默认加载hibernate.cfg.xml文件

                            Configuration conf =new Configuration().configure();

                            //以configuration创建SessionFactory

                            SessionFactory sf =conf.buildSessionFactory();

                            //创建Session

                            Session sess =sf.openSession();

                            //开始事务

                            Transaction tx = sess.beginTransaction();

                            //创建消息实例

                            News n = new News();

                            //设置消息标题和内容

                            n.setTitle(“标题”);

                            n.setContent(“内容:”+“消息内容”);

                            //保存消息

                            sess.save(n);

                            //提交事务

                            tx.commit();

                            //关闭Session

                            sess.close();

                            sf.close();

}

}

上面程序显示：执行session.save(NEWS)之前，先要获取Session对象。PO只有在Session的管理下才可完成数据库的访问。为了使用Hibernate进行持久化操作，通常需要以下几步：

①  开发持久化类，由POJO加映射文件组成

②  获取Configuration。

③  获取SessionFactory。

④  获取Session，打开事务。

⑤  用面向对象的方式打开数据库。

⑥  关闭事务，关闭Session。

对PO的操作必须在Session管理下才能同步到数据库。Session由SessionFactory工厂生产，SessionFactory是数据库编译后的内存镜像，通常一个应用对应一个SessionFactory对象。SessionFactory对象由Configuration对象生成，Configuration对象负责加载Hibernate配置文件。

 

9、  直接打印对象：

实际上打印的是Object的toString方法返回的字符串，该字符串由类名（对象是该类的一个实例）、标记符“@”和此对象哈希码的无符号十六进制表示组成。即：

         getClass().getName()+ ‘@’ + Integer.toHexString(hashCode())

 

10、 乐观锁（OptimisticLocking）和悲观锁(Pessimistic Locking)解决事务并发问题

一个典型的依赖数据库的悲观锁调用：

select * from account where name=”Erica” for update

这条 sql 语句锁定了 account表中所有符合检索条件（ name=”Erica”）的记录。本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。在Hibernate使用悲观锁十分容易，但实际应用中悲观锁是很少被使用的，因为它大大限制了并发性。

Hibernate的悲观锁，也是基于数据库的锁机制实现：

String hqlStr=”form TUser as user where user.name = ‘Erica’”;

Query query = session.creatQuery(hqlStr);

query.setLockMode(“user”,LockMode.UPGRADE);//加锁

List userList = query.list();

query.setLockMode对查询语句中，特定别名所对应的记录进行加锁（我们为TUser类指定了一个别名“user”），这里也就是对返回所有user记录进行加锁。

Hibernate的加锁模式有：

LockMode.NONE：无机制锁。

LockMode.WRITE：Hibernate在Insert和Update记录的时候会自动获取。

LockMode.READ：Hibernate在读取记录的时候会自动获取。

以上三种机制一般由Hibernate内部使用，如Hibernate为了保证Update过程中对象不会被外界修改，会在sava方法实现中自动为目标加上WRITE锁。

LockMode.UPGRADE:利用数据库的for子句加锁。

LockMode.UPGRADE_NOWAIT：Oracle的特定实现，利用Oracle的for updatenowait子句实现加锁。

上面这两种锁机制是我们在应用层较为常用的，加锁一般通过以下方法实现：

Criteria.setLockMode

Query.setLockMode

Session.lock

注意：只有在查询开始之前，即Hibernate生成sql之前设定加锁才会真正通过数据库的锁机制进行加锁处理。否则，数据已经通过不包含for update子句的Select SQL加载进来。

乐观锁（OptimisticLocking）：相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。

乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个“version”字段来实现。

读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

Hibernate 中可以通过 class 描述符的 optimistic-lock 属性结合 version描述符指定。现在，我们为之前示例中的 TUser 加上乐观锁机制。

1 ．首先为 TUser 的 class 描述符添加 optimistic-lock 属性：

<hibernate-mapping>

<class

name="org.hibernate.sample.TUser"

table="t_user"

dynamic-update="true"

dynamic-insert="true"

optimistic-lock="version"

> 

……

</class>

</hibernate-mapping>

optimistic-lock属性有如下可选取值：

none：无乐观锁

version：通过版本机制实现乐观锁

dirty：通过检查发生变动过得属性实现乐观锁

all：通过检查所有属性实现乐观锁。

其中通过 version 实现的乐观锁机制是Hibernate 官方推荐的乐观锁实现，同时也是 Hibernate 中，目前唯一在数据对象脱离 Session 发生修改的情况下依然有效的锁机制。因此，一般情况下，我们都选择 version 方式作为 Hibernate 乐观锁实现机制。