betway必威Java 面试前的根底准备 – 01通俗易懂的Nhibernate教程(1) —– 基本操作,映射,CURD

by admin on 2018年9月19日

动是在线网页编辑真的是免惯,还是
windows live writer 好。

网站架构:

下列一个清单用于最近之面试:(
清单是网上down的 )

1.图片

  1. static,final,transient
    等重要字之图
  2. foreach 实现原理
  3. synchronized 和 volatile关键字

  4. List,Map,Set
    及其各种实现类似,底层实现原理,实现类似的优缺点

  5. 设计模式(单例【懒汉,饿汉,静态代码块,线程安全无安全】,工厂,观察,包装)

  6. 多线程(Runable 和 Thread)

  7. 咦是线程池,
    以及线程池的亮点
  8. sleep() 和 wait() 的区别
  9. IO(字节,字符,序列,内存,对象,打印。。。)

  10. 照机制和反思建制

  11. 解析 xml文件几种植艺术的规律与特色 [
    Dom, SAX, PULL ]
  12. sql 和 nosql(mysql 和 redis)

  13. 数据结构和算法(栈,队列,链表,树,图,排序,搜索)

  14. JDK 源码

  15. JVM(GC
    算法,垃圾回收器,类加载器,双委派类型,Java
    内存模型,happens-before 原则)
  16. web 分布式 session 实现之主意(4种)

  17. SOA,RPC,dubbo

  18. 重补充加几个抢腐烂掉的点:override 和
    overload,final 和 finally,

betway必威 1

 

2.说明

Data  ———————–  
类库项目,数据访问层,由Nhibernate提供数据相关操作

Mapping ——————-    类库项目,映射文件还在这类型蒙

Model   ——————–    类型项目,实体层

XShop  ——————–     Mvc项目,UI层

 

 

static 关键字之企图:

  1. 图在类上(该类必须只能是其中类,访问中类的积极分子时,可以一直内部类名点调用)

  2. 意在方式及(可以经过类似名点调用,但是不克修饰构造方法,因为构造方法本身便是静态方法)

  3. 作用在代码块上(类吃加载时,代码块自动执行,并且仅实行同样次于,一般用来加载驱动或单例设计模式)
  4. 静态导包(使受导包内的静态成员可以直接当咱们一直的好像中一直运用,不欲带类名,比如
    Math 类的 PI 常量,但缺点很肯定,可读性性降低)

步骤:

final 关键字之作用:

  1. 作用在接近上
    (该类变为最终类,不可知叫持续)
  2. 图在性能上
    (属性改为常量,常量的地方不同意为改)
  3. 用意在术上
    (方法成为最终方法,不可知被子类重写)
  4. 企图在形参列表上(在方法类,值类型不允为修改,引用类型对象的属性可以吃改动,但是引用类型对象不克于改动)


final 的次点,要铭记这句话,使用  final
关键字修饰一个值类型变量时,值类型的价不允许修改;修饰的是引用型变量时,是指引用变量地址不克转换,但是引用变量所指向的靶子中的内容或得以变动之。**
综合到一些便是常量的地方不可知更改。**】

style=”color: #ff0000; font-size: large;”>1.安装Nhibernate

style=”color: #ff0000; font-size: large;”>2.配置Nhibernate

style=”color: #ff0000; font-size: large;”>3.创立实体类

style=”color: #ff0000; font-size: large;”>4.编纂映射文件

style=”color: #ff0000; font-size: large;”>5.创办数据库/表

6.CURD操作

7.测试

 

transient 关键字之意图:

  1.  

 

foreach 实现原理:

    foreach就是 java
中之增高for循环,语法: for(Type agr : Coll){ }

    其促成原理就是是采用了迭代器,所以会见较一般
for
循环会快速一点,但是也发出弊,就是不得不遍历元素,不能够修改元素。

第一步:安装Nhibernate,这等同步就是毫无说了,使用Nuget安装,看图

volatile 关键字图:

 

 

 

单链集合中的知识点:

单链集合的彻底接口是Collection,其下发出少数只子接口
List 和 Set,前者会储存重复元素,后者不克积存重复元素。

betway必威 2

1. List 集结特点:

         元素的存取顺序是平的,也足以储存重复元素

     List 集合实现类的挑三拣四标准 :
查询多便分选ArrayList, 增删多就分选LinkedList,
如果都多就是挑选ArrayList。

     List 集合实现类似中应用的
contains()和remove()方法底层依赖之equals()方法,如果只要使用这些方式,存入的实业类设实现equals()方法,

     可以采用LinkedList
来模拟站和排,需要动用的是该addFast(),addLast() 等方法,

     三种循环: 普通for ,迭代器,
增强for,

  • 习以为常 for
    循环能删除集合元素(记住要立即用循环变量减一)
  • 迭代器,能去除集合元素(只能用迭代器自身的
    remove 方法)
  • 增进 for
    循环,不能够去集合元素,只能用来遍历集合(普通数组也可遍历,而且于通常for快)

style=”font-size: medium;”>之前写过的List集合的博客: style=”color: #ff0000;”>【 style=”color: #ff0000;”>ArrayList
去除重复元素 style=”color: #ff0000;”>】

                                        
【List
实现非递归删除目录 style=”color: #ff0000;”>】

 

2. Set 集合的特性:

       元素的存取顺序不自然是一致的 (
Set集合在底层进行了排序,Hash算法去还并排序或者二叉树排序,不克管排好后的依次的储存的次第一定非相同
),不能够储存重复元素

   Set 集合常用实现类似:
HashSet,TreeSet,LinkedHashSet

   HashSet
底层去重新依赖之凡hashCode()方法和equals()方法,为了减小调用equals()方法的效率,一定要是更写hashCode()方法,因为只有当要存储的因素的
hash 值出现同时才会调用equals()方法进行判重。

  LinkedHashSet
能管元素的存取一致,因为来链表结构,又因有hash算法,就会去重。

  TreeSet的特点:

         
可以指定顺序,然后对象的囤积会仍指定的一一进行排序。

  实现排序的有数种植艺术:

       1 . 因素实体类实现
Comparable 接口,并贯彻 compareTo() 方法,最好还要还写 equals()
方法,

       2 . 写一个 Comparator (
比较器接口 ) 的实现类似,并贯彻 compare() 方法,在创立 TreeSet
集合时,将比较器对象传递进入,( 也得以无写实现类似,直接写单匿名内部类
)。然后 TreeSet 集合对象调用
add() 方法时便会见活动进行较(第一栽方式吧,会自动将实体类对象提升也
Comparable 类型调用重写后底 compareTo方法 ,

     
第二种植方式的口舌就会见调用比较器类的compare方法)compareTo方法与compare()是那个近乎之,不同的即是前者有吃加上的素调用,参数就出一个,后者来少数只参数,第一只参数是若长的元素,第二独参数是已增长的素,(当然,这有限种都见面失掉遍历集合,直到于此元素找到一个得体的职务,最酷之状态便是一旦遍历整个集合才找到)

style=”font-size: medium;”>之前写了之Set集合的博客: style=”color: #ff0000;”>【 style=”color: #ff0000;”>HashSet
存储于定义对象如何保管元素唯一性 style=”color: #ff0000;”> style=”font-size: large;”>】

style=”font-size: large;”>                                  
【 style=”font-size: large;”>TreeSet
如何确保元素的唯一性 style=”color: #ff0000;”> style=”font-size: large;”>】

style=”font-size: large;”>                                  
【 style=”font-size: large;”>LinkedHashSet
的概述和应用 style=”color: #ff0000;”> style=”font-size: large;”>】

 

双链集合中之知识点:

双链集合的到底接口是 Map ,Map中存储的凡
key-value 对,其中key是绝无仅有的,和 Set 集合一样,只是Map的唯一性针对让
key 。
  1.HashMap 和 Hashtable 的区别:

      仔细看就简单个号,会发现
Hashtable 不顶相符驼峰式命名,那是因他是比较的尽的本,Hashtable 出自
JDK1.0 版本,是线程安全之(导致效率低),HashMap 是 JDK1.2
版本出现的,是线程不安全之(所以效率高),这样一来 HashMap 就替了
Hashtable了。(这点可以和 StringBuffer 一样,然后出了 StringBuild
替代了StirngBuffer )。

再有重要之某些,就是 HashMap 允许 key 为
null键和null值,Hashtable 是无容许。

style=”font-size: medium;”>之前写的 Map 集合的博客: style=”color: #ff0000;”>【 style=”color: #ff0000;”>Map
集合概述及其特性 style=”color: #ff0000;”> style=”font-size: large;”>】

解析xml文件的老三栽艺术: [ DOM, SAX,
PULL]

DOM: style=”color: #ff0000;”>消耗内存:先管
xml文档都读到内存中,然后又就此 DOM API
来访问树形结构,并获取数据。这个写起来颇简单,但是好耗费内存。
SAX: style=”color: #ff0000;”>解析效率高,占用内存少,基于事件驱动的:更加简约地游说不怕是针对性文档进行逐个扫描,当扫描到文档
(document)开始与结束、元素 (element) 开始跟收、文档 (document)
结束等地方经常通事件处理函数,由事件处理函数做相应动作,然后继续同的围观,直至文档结束。
PULL:与 SAX 类似,也是因事件驱动,我们好调用它的 next()
方法,来博取下一个解析事件(就是开始文档,结束文档,开始标签,结束标签),当远在某个元素时得调用
XmlPullParser的getAttributte() 方法来博属性之价值,也不过调用它的
nextText() 获取本节点的值。

啊是线程池,
以及线程池的长处
:

style=”font-size: large;”>线程池的基本思维是一样种植对象池的思,开辟一片内存空间,里面存了累累
(未死)
的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池塘中收获一个,执行到位后线程对象归池,这样可免频繁创建线程对象所带动的属性开销,节省了系的资源。就吓于原去饭店打饭是每个人拘禁谁抢的胜利,谁先抢到谁先吃,有了线程吃后,就是散好队形,今天本人和你关系好,你先来就餐。比如:一个下要跟网络社交,有过多步骤需要拜访网络,为了不死主线程,每个步骤都创造个线程,在线程中及网络互动,用线程池就变的简单,线程池是针对线程的同种包装,让线程用起来越便利,只待创造一个线程池,把这些手续像任务同样放进线程池,在先后销毁时一旦调用线程池的绝迹函数即可。

单个线程的害处:

  • 老是new
    Thread新建对象性能差
  • style=”font-size: large;”>线程缺乏统一管理,可能无界定新建线程,相互之间竞争,及容许占了多系统资源导致死机或者OOM
  • style=”font-size: large;”>缺乏更多力量,如定时执行、定期执行、线程中断

线程池的裨益 :

  • style=”font-size: large;”>重用存在的线程,减少对象创建、消亡的支出,性能好。
  • style=”font-size: large;”>可使得控制最可怜并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
  • style=”font-size: large;”>提供定时执行、定期执行、单线程、并发数控制相当功能。

sleep() 和 wait() 的区别:

sleep() 来自 Thread 类,wait() 来自
Object 类
调用 sleep() 方法的过程遭到,线程不见面自由对象锁。而调用 wait()
方法线程会释放对象锁
sleep() 睡眠后不起被系统资源,wait() 让出系统资源其他线程可以占
CPU
sleep(milliseconds) 需要指定一个睡眠时,时间一模一样到会活动唤醒.

脚是故 windows live writer
写的,是当凡较网页的好多矣。。。。

第二步:配置Nhibernate

面向对象的老三非常特色和五异常骨干原则:

老三特别特点:

  • 封装
  • 继承
  • 多态

五格外中心尺度:

  • 单纯任务规范
  • 开放封闭原则
  • 轮换原则
  • 仰原则
  • 接口分离原则

详细:

style=”font-size: large; color: #ff0000;”>封装:所谓包,也就是将客观事物封装成抽象的接近,并且类可以管温馨之数码以及方就吃可信的类或目标操作,对不可信的拓信息隐藏。封装是面向对象的特色有,是目标和相近概念的重要特点。
简单的游说,一个近似就是一个装进了数额及操作这些多少的代码的逻辑实体。在一个靶中,某些代码或少数数据足以是私有的,不可知吃外边看。通过这种措施,对象对内部数据提供了不同级别的维护,以戒程序中无关之部分意外之变更或者错误的用了目标的个人部分。

继承: style=”font-size: medium;”>所谓继承是乘好吃有项目的靶子获得任何一个品类的对象的性质的点子。它支持按级分类的定义。继承是据这样同样种植力量:它可以使现有类的有所力量,并当无需另行编排原来的好像的动静下对这些效应进行扩展。
通过持续创建的新类称为“子类”或“派生类”,被接续的类称为“基类”、“父类”或“超类”。继承的历程,就是从一般到突出之长河。要实现连续,可以通过“继承”(Inheritance)和“组合”(Composition)来贯彻。继承概念的实现方式有二类:实现持续与接口继承。实现连续是据直接采用基类的性与章程而随便需额外编码的能力;接口继承是赖只是用性能与法的称谓、但是子类必须提供实现之能力;

多态: style=”font-size: medium;”>所谓多态就是因一个像样实例的一样方法在不同情形有不同表现形式。多态机制而拥有不同内部结构的目标足以共享相同之外部接口。这象征,虽然针对不同对象的具体操作不同,但由此一个官的接近,它们(那些操作)可以经过平等之章程赋予调用。

style=”font-size: large; color: #ff0000;”>多态三良因素:

  • 继承
  • 法重写
  • style=”font-size: medium; color: #000000;”>父类引用指向子类对象

    style=”font-size: large; color: #ff0000;”>单纯任务规范: style=”font-size: medium; color: #000000;”>指一个像样的法力一旦单纯,不能够全面。如同一个人数同,分配的做事无克尽多,否则一天到晚虽然忙忙碌碌的,但效率也高不起。

    style=”font-size: large; color: #ff0000;”>绽放封闭原则:一个模块于扩展性方面该是开放之只要于更改性方面当是封闭的。比如:一个大网模块,原来单纯服务端功能,而今天如果在客户端功能,那么当以毫无修改服务端功能代码的前提下,就会增加客户端功能的落实代码,这要求在筹划之初,就应有用服务端和客户端分开,公共部分虚幻出。

    style=”font-size: large; color: #ff0000;”>轮换原则:子类应当可以轮换父类并起于父类能够产出的其他地方。比如:公司来年度晚会,所有员工好到抽奖,那么不论是老职工或者新员工,也无是总部员工还是叫员工,都当可以与抽奖,否则即公司即不调和了。

style=”font-size: large; color: #ff0000;”>依赖原则:切切实实指抽象,上层依赖下层。假设B是较A低的模块,但B需要采取到A的效应,这个时候,B不应直接运用A中之具体类:
而该由B定义一架空接口,并出于A来兑现这抽象接口,B只使这个抽象接口:这样就直达了借助倒置的目的,B也解除了对A的仗,反过来是A依赖让B定义的空洞接口。通过上层模块难以避免依赖下层模块,假如B也直依赖A的落实,那么就可能导致循环依赖。

style=”font-size: large; color: #ff0000;”>接口分离原则:模块间如果由此架空接口隔离开,而休是通过具体的类强耦合起来。

2.1
这同样步要是有系统级的配备,如:连接字符串,数据库让,数据库方言等

2.2 创建 hibernate.cfg.xml文件( style=”color: #ff0000;”>XShop项目中)

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
  <!--Nhibernate对数据库操作是基于ISession(会话),可以理解为SqlConnection的封装,可通过SessionFactory创建-->
  <session-factory name="XShop">
    <!--连接提供程序-->
    <property name="connection.provider">NHibernate.Connection.DriverConnectionProvider</property>
    
    <!--连接字符串-->
    <property name="connection.connection_string">
      Server=.;initial catalog=XShopDb;Integrated Security=SSPI
    </property>
    
    <!--Nhibernate是一个支持多个数据库的Orm框架,然而几乎每个数据库产品都对Sql的实现都有所不同-->
    <!--Nhibernate通过dialect(方言)消除数据库之间的差异-->
    <property name="dialect">NHibernate.Dialect.MsSql2008Dialect</property>
    
    <!--是否在调试的时候打印Sql语句-->
    <property name="show_sql">true</property>
    
    <!--映射文件所在的程序集-->
    <mapping assembly="Mapping"/>
  </session-factory>
</hibernate-configuration>

style=”color: #ff0000; font-size: small;”>温馨提醒:如果发现在编写xml文件之早晚发现没有智能提醒,请把Nhibernate包的xsd文件复制到Vs安装目录中(参考百度)

style=”color: #ff0000; font-size: small;”>注意:Nhibernate配置文件的文本称必须也
hibernate.cfg.xml ,不可随便改变

 

设计模式:

其三步:创建实体类
Customer(Model项目)

单例设计模式:

大面积的单例模式主要发生懒汉和饿汉有数种,懒汉分线程安全和非安全,代码上来先:

3.1 代码

namespace Model
{
    public class Customer
    {
        public virtual int Id { get; set; }
        public virtual string Name { get; set; }
        public virtual string UserName { get; set; }
        public virtual string Password { get; set; }
        public virtual DateTime CreateTime { get; set; }
    }
}

style=”color: #ff0000; font-size: small;”>注意:实体类的性必须是virtual,否则Nhibernate会报错.why?因为这样Nhibernate就足以重写这些性的走访逻辑,比如
延迟加载..

1 . 懒汉式(线程不安全),我现喜好管它们喊懒加载

package com.msym.sort;

/**
 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  懒汉式(线程不安全)
 */
public class Singleton {

    private static Singleton instance = null;

    //私有化构造函数,这是单例模式必须的。
    private Singleton(){}

    public static Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

 

2 . 懒汉式(线程安全)

package com.msym.singleton;

/**
 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  懒汉式(线程安全)
 */

public class Singleton {

    private static Singleton instance = null;

    private Singleton(){}

    public static synchronized Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

季步:创建 Customer.hbm.xml
映射文件(Mapping项目)

3 . 饿汉式(静态成员变量)

package com.msym.singleton;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  饿汉式(静态成员变量)
 */
public class Singleton {
    
    private static Singleton instance = new Singleton();
    
    private Singleton(){}

public static Singleton getInstance(){
return instance;
}
}

 

4.1 代码:

<?xml version="1.0" encoding="utf-8" ?>








注意:

1.映射文件命名规则: 
类名.hbm.xml  ,不可随便改变

style=”color: #ff0000; font-size: small;”>2.映射文件的变更策略要也:嵌入至程序集

4 . 饿汉式(采用静态代码块)

package com.msym.singleton;

/**
 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  饿汉式(静态代码块)
 */
public class Singleton {

    private static Singleton instance = null;

    static{
        instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

 

5 . 采用静态内部类

package com.msym.singleton;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  静态内部类的形式
 */
public class Singleton {
    /**
     * 静态内部类,用于创建单例对象
     * @author 码上猿梦
     *  http://www.cnblogs.com/daimajun/
     */
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    private Singleton(){}
    
    /**
     * 类名.内部类成员变量
     * @return
     */
    public static final Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

 

第五步:创建数据库及说明

6 . 重新校验锁

package com.msym.singleton;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  双重校验锁
 */
public class Singleton {
    /*
     * 使用volatile修饰
     */
    private volatile static Singleton instance = null;
    
    private Singleton(){ }
    
    /**
     * 两次判断对象是否为空
     * @return
     */
    private static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class) {
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

5.1 创建数据库

CREATE DATABASE XShopDb
GO

 

5.2  创建表

   style=”font-size: medium;”>5.2.1创建表的有限种办法–手动创建

    style=”color: #ff0000; font-size: small;”>注意:创建的表结构应当同照文件一律

    style=”font-size: medium;”>5.2.1创建表的少种方法–使用 style=”color: #0000ff;”>SchemaExport生成的Sql

    代码:好创造一个控制台项目还是Winform项目走下面这段代码

NHibernate.Cfg.Configuration configuration = new NHibernate.Cfg.Configuration().Configure();
NHibernate.Tool.hbm2ddl.SchemaExport schemaExport = new NHibernate.Tool.hbm2ddl.SchemaExport(configuration);
//打印Sql脚本,但不执行
 schemaExport.Create(true, false);

//导出至文件
//schemaExport.SetOutputFile(@”c:/schma.sql”);

       结果:

       
betway必威 3

工厂模式:

横分三类:

  • 粗略工厂模式
  • 厂子方法模式
  • 抽象工厂模式

    style=”font-size: large;”>前两者可以分为联合,就是厂方法模式。

那工厂方法模式以及抽象工厂
模式的自查自纠:

工厂方法模式:
      style=”color: #ff0000;”>一个空洞产品类,可以派生出多个实际产品类。  
      style=”color: #000000;”>一个虚无工厂类,可以派生出多独具体工厂类。  
      每个具体工厂类只能创造一个具体产品类的实例。
架空工厂模式:
      style=”color: #ff0000;”>多个泛产品类,每个抽象产品类可以派生出多只具体产品类。  
      一个架空工厂类,可以派生出多个具体工厂类。  
      每个具体工厂类可创建多独实际产品类似的实例。  
区别:
     工厂方法模式只出一个虚无产品类,而空虚工厂模式来多独。  
    
工厂方法模式之具体工厂类只能创造一个切实产品类似的实例,而空虚工厂模式可创建多单。

 

 

【下面排序默认都为升序】

 

排序代码:选择,插入,气泡

选排序的思路:(n 也要排序的数字只数,都设升序排列)

      style=”font-size: medium;”> style=”font-size: large;”>将要排序的对象分为两单部分,一个是前者已排序(假定也升序),一个后端未排序的,每次由后端选择一个无比小价,并放入前端序列的末尾,这样太多循环(n

  • 1)次后哪怕排序完成了。【 style=”color: #ff0000;”>最开头时,前端部分无元素,后端元素呢周】

    style=”font-size: large;”>如图:

        
betway必威 4

插入排序的思路:

     style=”font-size: large;”>像玩扑克牌一样,可以将牌分为两积聚,每次打后同堆放着挤出第一摆放,插入到眼前同堆积中之方便位置,这样最好多循环(n

  • 1)次就是好了排序。【 style=”color: #ff0000;”>最开始时,前同一堆只生一个因素,后同样积是多余的元素】

如图:

     
betway必威 5

气泡排序的思绪:

     style=”font-size: large;”>顾名思义,最特别的因素会如气泡一样移至右端,利用比较相邻元素的措施,将较充分之素交换至右端,所以非常的因素会没完没了的朝右侧走,直到移动及当的职位(就是右端元素于她充分之位置)为止。【 style=”color: #ff0000;”>当 i 和 i + 1
从不发出了元素交换位置,就标志排序已形成】

style=”font-size: large;”>如下图:

       
betway必威 6

择排序,插入排序,冒泡排序:

package com.msym.sort;
  
/**
 * 排序算法:
 *      选择,插入,气泡
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 */
public class BasicSort {
    public static void selectionSort(int[] number) {
        for (int i = 0; i < number.length - 1; i++) {
            int minIndex = i;//假设第 i 个元素最小, 最开始是假设第一个元素最小
            for (int j = i + 1; j < number.length; j++) {
                if (number[j] < number[minIndex])
                    minIndex = j;//每次循环找到后端最小值的角标
            }
            if (i != minIndex) //如果i == minIndex,说明最小值的角标就是 i,不需要交换, 这里的 i 指的是位置.
                swap(number, i, minIndex);
        }
    }
    //插入排序  
    public static void injectionSort(int[] number) {
        for (int j = 1; j < number.length; j++) {
            int tmp = number[j]; //每次抽取后一堆的第一个元素
            int i = j - 1; //前一堆元素的最后一个,用于下面遍历的起点
            while (tmp < number[i]) { //最先和前一堆最后一个元素进行比较,然后依次往前进行比较
                number[i + 1] = number[i];
                i--;
                if (i == -1)
                    break;
            }
            number[i + 1] = tmp; //将 tmp 放在 i 的位置上
        }
    }
    //冒泡排序
    public static void bubbleSort(int[] number) {
        boolean flag = true;
        for (int i = 0; i < number.length - 1 && flag; i++) {
            flag = false; //每次将标志位重置为 false
            for (int j = 0; j < number.length - i - 1; j++) {
                if (number[j + 1] < number[j]) {
                    swap(number, j + 1, j);
                    flag = true; //交换过元素就将标志位改为 true
                }
            }
        }
    }
  
    private static void swap(int[] number, int i, int j) {
        int t;
        t = number[i];
        number[i] = number[j];
        number[j] = t;
    }
}

第六步:CURD操作(Data项目)

Shaker 排序法,改良后底血泡排序:

     排序思路:

          
方法就在气泡排序的双向进行,先让气泡排序由左向右进行,再来深受气泡排序由右为左进行,如此成就同样破排序的动作,而而要使left与right两个旗标来记录左右简单端都排序的因素位置。

如下图:

       
betway必威 7

代码如下:

package com.msym.sort;

/**

 * 改良的气泡排序
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class ShakerSort {
    public static void sort(int[] number) {
        int i, left = 0, right = number.length - 1, shift = 0; //
        while (left < right) { 
            // 向右进行气泡排序,一次循环,最大值到达最右端
            for (i = left; i < right; i++) {
                if (number[i] > number[i + 1]) {
                    swap(number, i, i + 1);
                    shift = i;
                }
            }
            right = shift; 
            // 向左进行气泡排序,一次循环,最小值到达最左端
            for (i = right; i > left; i--) {
                if (number[i] < number[i - 1]) {
                    swap(number, i, i - 1);
                    shift = i;
                }
            }
            left = shift;
        }
    }

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

6.1
上面我们提过,所有数据库操作都是经ISession对象操作,而ISession可以透过ISessionFactory创建

style=”font-size: medium;”>—–创建HbmHelper类–获取ISessionFactory

namespace Data
{
    public class HbmHelper
    {
        private static ISessionFactory _sessionFactory;
        public static ISessionFactory CurrentSessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                {
                    //创建SessionFactory
                    _sessionFactory = new Configuration().Configure().BuildSessionFactory(); 
                }
                return _sessionFactory;
            }
        }
    }
}

 

style=”font-size: medium;”>——-从ISessionFactory中创建session

private ISession _session = HbmHelper.CurrentSessionFactory.OpenSession();

 

——添加数据访问基类
BaseDal<T>

namespace Data
{
    /// <summary>
    /// 数据访问基类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class BaseDal<T> where T : class
    {
        //从ISessionFactory中创建session
        private ISession _session = HbmHelper.CurrentSessionFactory.OpenSession();

        #region ------------------   CURD    ----------------
        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="model"></param>
        public int Insert(T model)
        {

int id=(int) _session.Save(model);
_session.Flush();
return id;

}

///

/// 更新
///

/// public void Update(T model)
{
//使用工作
using (ITransaction ts = _session.BeginTransaction())
{
try
{
_session.Update(model);
_session.Flush();
ts.Commit();
}
catch (Exception)
{
ts.Rollback();
throw;
}
}
}

///

/// 删除
///

/// public void Delete(T model)
{
_session.Delete(model);
_session.Flush();
}

///

/// 查询
///

/// ///
public T Query(int id)
{
return _session.Get(id);
}

        #endregion
    }
}

Shell 排序法 ,改良后的插入排序:

代码如下:

package com.msym.sort;

/**

 * 改良的插入排序
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class ShellSort {
    public static void sort(int[] number) {
        int gap = number.length / 2;
        while (gap > 0) {
            for (int k = 0; k < gap; k++) {
                for (int i = k + gap; i < number.length; i += gap) {
                    for (int j = i - gap; j >= k; j -= gap) {
                        if (number[j] > number[j + gap]) {
                            swap(number, j, j + gap);
                        } else
                            break;
                    }
                }
            }
            gap /= 2;
        }
    }

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

 

很快清除序 -01:

package com.msym.sort;

/**

 * 快速排序法(一)
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class QuickSort {
    public static void sort(int[] number) {
        sort(number, 0, number.length - 1);
    }

private static void sort(int[] number, int left, int right) {
if (left < right) { int s = number[left]; int i = left; int j = right + 1; while (true) { // 向右找 while (i + 1 < number.length && number[++i] < s); // 向左找 while (j - 1 > -1 && number[–j] > s);
if (i >= j)
break;
swap(number, i, j);
}
number[left] = number[j];
number[j] = s;
sort(number, left, j – 1);
// 对左边进行递回
sort(number, j + 1, right);
// 对右边进行递回
}
}

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}

}

第七步:添加数量,测试

高速解序 -02:

package com.msym.sort;

/**

 * 快速排序法(二)
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 */
public class QuickSort {
    public static void sort(int[] number) {
        sort(number, 0, number.length - 1);
    }

private static void sort(int[] number, int left, int right) {
if (left < right) { int s = number[(left + right) / 2]; int i = left - 1; int j = right + 1; while (true) { // 向右找 while (number[++i] < s); // 向左找 while (number[--j] > s);
if (i >= j)
break;
swap(number, i, j);
}
sort(number, left, i – 1); // 对左边进行递回
sort(number, j + 1, right); // 对右边进行递回
}
}

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

7.1 添加多少

betway必威 8

7.2
创建单元测试项目,添加测试类:

namespace DataTest
{
    [TestClass]
    public class BaseDalTest
    {
        private BaseDal<Customer> _customerDal = new BaseDal<Customer>();

[TestMethod]
public void GetTest()
{
var result = _customerDal.Query(1);
Assert.AreEqual(result.Name, “张小军”);
}

[TestMethod]
public void InsertTest()
{
Customer customer = new Customer()
{
Name = “张三”,
Password = “654321”,
UserName = “zhs”
};

int id = _customerDal.Insert(customer);

var result = _customerDal.Query(id);
Assert.AreEqual(customer.UserName, result.UserName);

}

[TestMethod]
public void UpdateTest()
{
var result = _customerDal.Query(1);
result.Name = “王五”;
_customerDal.Update(result);
var r2 = _customerDal.Query(1);
Assert.AreEqual(result.Name,r2.Name);
}

[TestMethod]
public void DelTest()
{
var result = _customerDal.Query(1);
_customerDal.Delete(result);
var r2 = _customerDal.Query(1);
Assert.IsNotNull(r2);
}
}
}

迅猛解序 -03:

package com.msym.sort;

/**

 * 快速排序法(三)
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class QuickSort {
    public static void sort(int[] number) {
        sort(number, 0, number.length - 1);
    }

private static void sort(int[] number, int left, int right) {
if (left < right) { int q = partition(number, left, right); sort(number, left, q - 1); sort(number, q + 1, right); } }
private static int partition(int number[], int left, int right) {
int s = number[right];
int i = left – 1;
for (int j = left; j < right; j++) { if (number[j] <= s) { i++; swap(number, i, j); } } swap(number, i + 1, right); return i + 1; }
private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

 

联排序法:

package com.msym.sort;

/**

 * 合并排序法
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class MergeSort {
    public static int[] sort(int[] number1, int[] number2) {
        int[] number3 = new int[number1.length + number2.length];
        int i = 0, j = 0, k = 0;
        while (i < number1.length && j < number2.length) {
            if (number1[i] <= number2[j])
                number3[k++] = number1[i++];
            else
                number3[k++] = number2[j++];
        }
        while (i < number1.length)
            number3[k++] = number1[i++];
        while (j < number2.length)
            number3[k++] = number2[j++];
        return number3;
    }
}

代码: style=”font-size: medium;”>http://files.cnblogs.com/files/zhxj/XShop0822.zip

style=”color: #ff0000; font-size: large;”>原创文章,转载请注明出处: style=”color: #ff0000; font-size: large;”>http://www.cnblogs.com/zhxj/      

 

 

2015.08.22
–张小军

次划分搜寻法:

package com.msym.search;

/**

 * 二分搜寻法(搜寻原则的代表)
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class BinarySearch {
    public static int search(int[] number, int des) {
        int low = 0; //左
        int upper = number.length - 1; //右
        while (low <= upper) { //只要左边小于等于右边就进循环
            int mid = (low + upper) / 2; //取中间元素的角标(自动取整),然后进行比较
            if (number[mid] < des)
                low = mid + 1;
            else if (number[mid] > des)
                upper = mid - 1;
            else
                return mid;
        }
        return -1; //找不到就返回 -1
    }

public static void main(String[] args) {
int[] number = { 1, 4, 2, 6, 7, 3, 9, 8 };
QuickSort.sort(number); //先排序
int find = BinarySearch.search(number, 3); //找到值为 3 的要素
if (find != -1)
System.out.println(“找到数值为索引” + find);
else
System.out.println(“找不至数值”);
}
}

 

jdbc 基础:

package com.msym.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 */
public class temp{
    public static void main(String[] agrs) throws Exception{
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql:127.0.0.1:3306/Demo_db";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);
        String sql = "select * from msym_user where name = ? ";
        PreparedStatement st = conn.prepareStatement(sql);
        st.setString(1,"码上猿梦");
        ResultSet rs = st.executeQuery(sql);
        while(rs.next()){
            int id = rs.getInt("id");
            String nickName = rs.getString("nickName");
            System.out.print("id : " + id + "; " + "nick :" + nickName);
        }
    }
}

放飞资源的betway必威代码:

        // 4.释放资源.
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            rs = null; // 为了让JVM垃圾回收更早回收该对象.
        }

if (st != null) {
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
st = null;
}

if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
conn = null;
}

会晤讲话技术: 【session 和 cookie】

cookie
的几点:

  • cookie 用于携带的数据量最可怜也 4KB

  • 一个服务器最多往一个浏览器保存20只 cookie

  • 一个浏览器最多保留300个 cookie

 

自非知底到的转折以及重定向:

style=”font-size: large;”>转发和重定向会清空上一个
response中缓存的多少,所以转发或者重定向前的有的
response都是没用的,只有靶资源的
response的输出才是行之有效之【也不怕是最后一个响应的数目才会为客户端接收,其他的响应数据还让排除了】

 

 

 

补充:

今日看到同样段落代码,如下:

package com.msym.jyaml;

public class Demo {

public static void main(String[] args) {
Integer a = 1;
Integer b = 1;
Integer b2 = new Integer(1);

Integer c = 127;
Integer d = 127;

Integer e = 128;
Integer f = 128;
System.out.println(a==b);//true

        System.out.println(b==b2);//false
        System.out.println(c==d);//true
        System.out.println(e==f);//false
    }
}

此提到到了机关装箱拆箱和 Integer
的一个里边类 IntegerCache。

     结果为什么会冒出如此的,那是因
JVM 内部发生一个优化机制,当数值比小(-128~127)时,会下 Integer
类中之一个之中类
IntegerCache类的目标将那个储存起来,如果下次要重新装箱一个一致大小的数字(-128~127里边),就径直得到前的价了,这些比粗的数值使用的是千篇一律块存储空间,当然,如果运用了
new 操作符,那么就得会开发一个初的内存空间用来囤积数据。

框架基础:

Spring:

IoC:从 Spring
角度来讲,之前的应用程序去 new 对象的权利让 Spring
夺取了,称为控制反转。

DI: 从应用程序的角度讲,自己不再需要
new 对象了,只待提供依赖对象的 set
方法【使用注解后,只待而该改为成员变量即可,不欲 set
方法了】,等待 Spring 容器注入该目标,称为依赖注入。

SpringMVC:

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图