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

采用是在线网页编辑真的是休习惯,还是
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,

必威体育 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,前者会储存重复元素,后者不可知积存重复元素。

必威体育 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”);

       结果:

       
必威体育 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;”>如图:

        
必威体育 4

插入排序的思路:

     style=”font-size: large;”>像玩扑克一样,可以以牌分为两堆放,每次由晚一致积中抽出第一摆放,插入到前方同一堆着之相当位置,这样极其多循环(n

  • 1)次就是得了排序。【 style=”color: #ff0000;”>最初步经常,前一样积只出一个素,后同堆是剩下的素】

如图:

     
必威体育 5

气泡排序的思路:

     style=”font-size: large;”>顾名思义,最要命之要素会如气泡一样移至右端,利用比较相邻元素的办法,将于生的因素交换至右端,所以非常的素会不断的为右侧走,直到移动至相当的职(就是右端元素于其那个之职位)为止。【 style=”color: #ff0000;”>当 i 和 i + 1
尚未发过元素交换位置,就标明排序已做到】

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

       
必威体育 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两单旗标来记录左右鲜端都排序的因素位置。

如下图:

       
必威体育 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 添加多少

必威体育 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);
        }
    }
}

放资源的代码:

        // 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:

相关文章

Leave a Comment.