maps是一个HashMap对象,请遍历maps中每个元素(笔试)

1.maps是一个HashMap对象,请遍历maps中每个元素

             // 创建一个HashMap对象     

        java.util.HashMap<Integer, String> maps =newjava.util.HashMap<Integer, String>();     

               

        // 装入一个键值对     

        for(inti = 0; i <10; i++) {     

            intnum = i;     

            String name ="学生"+ i;       

            maps.put(num, name);         

        }     

//增加一个键值对，加入K相同的键值对，则会替换已经存在的键值对     

        maps.put(10,"学生5");     

        maps.put(4,"新学生");        

 

 

  

2。numArray是一个整型数组，请用冒泡方式排序，以递增方式保存在数组中

（1）递减

         

public class Test
{
	public static void main(String args[])
	{
		int[] arr = {4, 1, 2, 6, 3, 8, 9, 10, 7, 5};
		
		for (int i = 0; i < 10; i++)
			System.out.print(arr[i] + " ");
		System.out.println();
		
		for (int i = 0; i < 10 - 1; i++)
			for (int j = 0; j < 10 - 1 - i; j++)
			{
				if (arr[j] > arr[j + 1])
				{
					int temp = arr[j];
                                     	arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		for (int i = 0; i < 10; i++)
			System.out.print(arr[i] + " ");
	}
}

（2）

public class Paixu {

public static void main(String[] args) {
int [] myInt=new int[]{37,47,23,-5,19,56};
int t=0;//比较运算时交换中间数
final int len=myInt.length;
for(int i=0;i<len-1;i++){//控制所有数字都被比较循环
for(int j=0;j<len-i-1;j++){//控制每个数和数组里面其他数一一比较
if(myInt[j]>myInt[j+1]){
t=myInt[j];
myInt[j]=myInt[j+1];
myInt[j+1]=t;
}
}
}
for(int r=0;r<len;r++){//控制输出结果
System.out.println(myInt[r]);
}
}
}

3.struts1.x原理

谈到Struts,我们就不得不提到MVC设计模式。MVC即Model-View-Controller的缩写，它是web应用当中的常用的设计模式。MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。

Struts是MVC的一种实现，它很好的结合了Jsp,Java Servlet,Java Bean ,Taglib等技术。那么我们来看看Struts框架的工作原理：

控制：在Struts中，ActionServlet起着一个控制器（Controller）的作用。ActionServlet是一个通用的控制组件。这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。它截取和分发这些请求到相应的动作类（这些动作类都是Action类的子类）。另外控制组件也负责用相应的请求参数填充 Action Form（通常称之为FromBean）,并传给动作类（通常称之为ActionBean）。动作类实现核心商业逻辑，它可以访问java bean 或调用EJB。所有这些控制逻辑利用Struts-config.xml文件来配置。

视图：主要是由Jsp来控制页面输出的。它接收到Action Form中的数据，利用html，taglib(标签)，bean，logic等显示数据。

模型：在Struts中，主要存在三种bean,分别是：Action,ActionForm,EJB或者Java Bean。ActionForm用来封装客户请求信息，Action取得ActionForm中的数据，再由EJB或者Java Bean进行处理。

3 Struts 优点与缺点

优点：1.利用Struts提供的taglib可以大大节约开发时间。2. 表现与逻辑分离。 3.维护扩展比较方便。 4 便于团队开发 
 Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。

4.hibernate中 many-to-one  配置在多的一方还是  一的 一方

   多的一方

 

5.hibernate 中，get()与load（）区别？

Hibernate中有两个极为相似的方法get()与load(),他们都可以通过指定的实体类与ID从数据库中读取数据,并返回对应的实例,但Hibernate不会搞两个完全一样的方法的，它们间的不同在于:

　１．如果找不到符合条件的纪录，get()方法将返回null．而load()将会报出ObjectNotFoundEcception．

　２．load()方法可以返回实体的代理类实例，而get()永远只返回实体类．

    ３．load()方法可以充分利用二级缓存和内部缓存的现有数据，而get()方法只在内部缓存中进行查找，如没有发现对应数据将跳过二级缓存，直接调用ＳＱＬ完成查找．

 

 

6.hibernate中写出主键生成策略native与assigned的区别

   在用Hibernate的时候，当有表中的主键是库自动生成的时候将使用native。
<generator class="native"></generator>
而当是自己添加的时候则需要改为assigned。
<generator class="assigned"></generator>
否则将会出现异常！

 Hibernate优点
(1) 对象/关系数据库映射(ORM)
它使用时只需要操纵对象，使开发更对象化，抛弃了数据库中心的思想，完全的面向对象思想
(2) 透明持久化(persistent)
带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。这些对象可能是普通的JavaBeans/POJO，这个对象没有实现第三方框架或者接口，唯一特殊的是他们正与（仅仅一个）Session相关联。一旦这个Session被关闭，这些对象就会脱离持久化状态，这样就可被应用程序的任何层自由使用。（例如，用作跟表示层打交道的数据传输对象。）           
(3) 事务Transaction(org.hibernate.Transaction)
 应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很短。它通过抽象将应用从底层具体的JDBC、JTA以及CORBA事务隔离开。某些情况下，一个Session之内可能包含多个Transaction对象。尽管是否使用该对象是可选的，但无论是使用底层的API还是使用Transaction对象，事务边界的开启与关闭是必不可少的。
(4) 它没有侵入性，即所谓的轻量级框架
(5) 移植性会很好
(6) 缓存机制，提供一级缓存和二级缓存
(7) 简洁的HQL编程
 
2. Hibernate缺点
(1)  Hibernate在批量数据处理时有弱势
(2) 针对单一对象简单的增删查改，适合于Hibernate,而对于批量的修改，删除，不适合用Hibernate,这也是OR框架的弱点；要使用数据库的特定优化机制的时候，不适合用Hibernate

 

 

算法

1.写出队列Queue的维护程序，实现队列的初始化，进行队列，出队列

2.归并排序

      归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

 

1. void MemeryArray(int a[], int n, int b[], int m, int c[])  
2. {  
3.     int i, j, k;  
4.   
5.     i = j = k = 0;  
6.     while (i < n && j < m)  
7.     {  
8.         if (a[i] < b[j])  
9.             c[k++] = a[i++];  
10.         else  
11.             c[k++] = b[j++];   
12.     }  
13.   
14.     while (i < n)  
15.         c[k++] = a[i++];  
16.   
17.     while (j < m)  
18.         c[k++] = b[j++];  
19. }  

可以看出合并有序数列的效率是比较高的，可以达到O(n)。

解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

1. //将有二个有序数列a[first...mid]和a[mid...last]合并。  
2. void mergearray(int a[], int first, int mid, int last, int temp[])  
3. {  
4.     int i = first, j = mid + 1;  
5.     int m = mid,   n = last;  
6.     int k = 0;  
7.       
8.     while (i <= m && j <= n)  
9.     {  
10.         if (a[i] <= a[j])  
11.             temp[k++] = a[i++];  
12.         else  
13.             temp[k++] = a[j++];  
14.     }  
15.       
16.     while (i <= m)  
17.         temp[k++] = a[i++];  
18.       
19.     while (j <= n)  
20.         temp[k++] = a[j++];  
21.       
22.     for (i = 0; i < k; i++)  
23.         a[first + i] = temp[i];  
24. }  
25. void mergesort(int a[], int first, int last, int temp[])  
26. {  
27.     if (first < last)  
28.     {  
29.         int mid = (first + last) / 2;  
30.         mergesort(a, first, mid, temp);    //左边有序  
31.         mergesort(a, mid + 1, last, temp); //右边有序  
32.         mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
33.     }  
34. }  
35.   
36. bool MergeSort(int a[], int n)  
37. {  
38.     int *p = new int[n];  
39.     if (p == NULL)  
40.         return false;  
41.     mergesort(a, 0, n - 1, p);  
42.     delete[] p;  
43.     return true;  
44. }  

归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)。因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N*logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的。

 

 

3.二叉树插入一个数n,    查找二叉树中是否有包含n ,如果有返回1，没有返回-1.

 

一、面向过程与面向对象的区别：
前者是一种谓语和宾语的关系；后者是一种主语和谓语的关系。

二、面向对象的三个特征：
1.封装 2.继承 3.多态

三、类与对象：
对象又称作实例，是实际存在的该类事物的每个个体。类是对某一类事物的描述，是抽象的、概念上的定义。面向对象设计的重点是类的设计。

四、对象的比较：
1 “= =”运算符与equals()方法的区别：前者辨别实质是否相等；后者辨别长相是否相等。

五、实现类的封装性：
1.不能让外面的类随意修改一个类的成员变量；
2.在定义一个类的成员（包括变量和方法），使用private关键字说明这个成员的访问权限，只能被这个类的其他成员方法调用，而不能被其他的类中的方法所调用；
3.为实现封装性，常将类的成员变量声明为private,再通过public的方法来对这个变量进行访问。对一个变量的操作，一般都有读取和赋值操作，我们一般定义两个方法来实现这两种操作，即：getXxx()与setXxx()；
4.一个类就是一个模块，我们应该让模块仅仅公开必须要让外界知道的内容，而隐藏其他的一切内容。再进行程序设计时，应尽量避免一个模块直接修改或操作另一个模块的数据，模块设计追求强内聚（许多功能尽量在类的内部独立完成，不让外面干预），弱耦合（提供给外部尽量少的方法调用）。

六、构造函数的定义与作用：
1.特征：名称与类相同；不含返回值；不能在方法中用return返回一个值注意：构造方法里不含返回值的概念是不同与void的，在定义构造方法时加了void，结果这个方法就不再被自动调用了。
2.作用：当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码。

七、若类中已定义了一个构造方法，编译器就不再自动产生类似public Person(){ }的构造方法。

八、this引用句柄的应用：
1、类的成员名和对其进行赋值的成员方法的形参变量同名时，使用this便于理解；
2、假设我们有一个容器类和一个部件类，在容器类的某个方法中要创建部件类的实例对象，而部件类的构造方法要接收一个代表其所在容器的参数。
3、构造方法是在产生对象时被java系统自动调用的，我们不能在程序中象调用其他方法一样去调用构造方法。不是用构造方法名，而是用this的形式，根据其中的参数列表，选择相应的构造方法。

九、垃圾回收过程分析：java中的finalize()方法；System.gc的作用。 Finalize()的调用是在无用对象被回收前发生的。

一○、static 静态方法：
1、在静态方法中只能直接调用同类中其他的静态成员，而不能直接访问类中的非静态成员。原因是对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象；
2、静态方法不能以任何方式引用this和super关键字；
3、main（）方法是静态的，因此，JVM在执行main方法时不创建main方法所在的类的实例对象，因此在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

一一、JVM在程序执行时，只有在调用其他类的时候，才加载这个类并将其初始化（即将构造方法及静态变量进行加载并初始化。

一二、单态设计模式：采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只能产生严格取得其对象实例的方法。若我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类的内部仍可以产生该类的对象。

一三、内部类：
1、在类中直接定义的内部类，嵌套类可直接访问嵌套他的类的成员，包括private成员，但嵌套类的成员却不能被嵌套它的类直接访问；在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，若在该方法和内部类中都没有定义过这个变量，内部类中对this 的引用会被传递给那个外部类对象的引用；若用 static 修饰一个外部类，这个类就相当于是一个外部定义的类，所以 static 的内部类中可声明static 成员，但非static 的内部类中的成员是不能声明为 static 的，static 的内部类不能再使用外层封装类的非 static的成员变量。
例：若函数的局部变量，内部类的成员变量，外部类的成员变量重名，则应该按下面的程序代码所使用的方式来明确指出我们真正要访问的变量。
public class Outer
{
private int size;
public class inner
{
private int size;
public void doStuff(int size)
{
size++; //应用doStuff函数的形参
this.size++; //引用Inner类的成员变量
Outer.this.size++; // 引用Outer类的成员变量
}
}
}
2、在方法中定义的内部类：在方法中定义的内部类只能访问方法中的final 类型的局部变量，用final 定义的局部变量相当于一个常量，它的生命周期超出方法运行的生命周期。3、在内部类中的方法可以访问外部类的成员变量，而外部类的方法不能直接访问内部类的成员变量，若要访问，除非在内部类中再定义一个构造方法，这个构造方法的参数是外部类。

一四、在一个类中定义的局部变量，编译器可以对他初始化，但在一个方法中定义的局部变量，编译器不对它初始化。

---

   不管是面向对象，还是面向过程，都体现了一种软件重用的思想！只不过面向过程中重用的是过程和函数，但是面向对象重用的是类，一种将数据和处理数据的过程及函数封装在一起的实体，其实面向对象中的过程和函数和面向过程中的分别不是很大，所以数据流图和伪代码还是有用的。面向对象一个很大的好处就是数据和方法的封装，由此面向对象的三大特性得到发挥。  

---

    如果是对这两种技术掌握水平相同的两个人来比较的话，oo并不会增加分析、设计、编码的复杂度。相反，由于oo提供了更多更有效的将复杂问题分解的手段和方法，反而能降低设计、编码的复杂度。当然，对于oo的初学者来说，可能会有一些困难，特别是对于由结构化方法转到oo方法的时候，会遇到一定的思维障碍。但突破了这个障碍，你会发现，用OO更简单。