互联网笔试题答案

矩阵转置再相乘

二叉树的深度

***p


迭代



1.给定任意一个字符串，字符串最大长度1000，计算出最长的回文字符串长度。

2.有用户对各车系评分如下表，请按要求写出对应的sql语句。
请给出针对2个及以上车系做出评价的用户信息并按照所做的评分的平均值由高到底排序。
3.输入蛇形矩阵宽度N,输出整个蛇形矩阵的结果。

#include
int main()
{
int n;
static int a[100][100];
int i=0,j=0;
int k,x,y;
//printf("请输入整数N，N<=100\n");
scanf("%d",&n);
for(k=1;k<=n*n;k++)
{
a[i][j]=k;
if((i+j)%2==0)
{
if(i!=n-1&&j!=0)
{
i=i+1;
j=j-1;
}
else if(i==n-1)
{
// j=j+1;
break;
}
else
{
i=i+1;
}

}
else
{
if(i!=0&&j!=n-1)
{
i=i-1;
j=j+1;
}
else if(j==n-1)
{
break;
//i=i+1;
}
else
{
j=j+1;
}
}

}
for(x=0;x{
for(y=0;y{
if(y==(n-x-1))
printf("%d",a[x][y]);
else
printf("%d ",a[x][y]);
}
printf("\n");
}
return 0;
}


4 说明stack和heap的区别。
1.heap是堆，stack是栈。2.stack的空间由操作系统自动分配和释放，heap的空间是手动申请和释放的，heap常用new关键字来分配。3.stack空间有限，heap的空间是很大的自由区。在Java中，若只是声明一个对象，则先在栈内存中为其分配地址空间，若再new一下，实例化它，则在堆内存中为其分配地址。4.举例：数据类型 变量名；这样定义的东西在栈区。如：Object a =null; 只在栈内存中分配空间new 数据类型();或者malloc(长度); 这样定义的东西就在堆区如：Object b =new Object(); 则在堆内存中分配空间

选择题：

数据库事务 ，其四个属性是什么？

原子性(ATOMICITY):
一个事务要被完全的无二义性的做完或撤消。在任何操作出现一个错误的情况下，构成事务的所有操作的效果必须被撤消，数据应被回滚到以前的状态。

一致性(CONSISTENCY):
一个事务应该保护所有定义在数据上的不变的属性(例如完整性约束)。在完成了一个成功的事务时，数据应处于一致的状态。换句话说，一个事务应该把系统从一个一致-状态转换到另一个一致状态。举个例子，在关系数据库的情况下，
一个一致的事务将保护定义在数据上的所有完整性约束。

隔离性(ISOLATION):
在同一个环境中可能有多个事务并发执行，而每个事务都应表现为独立执行。串行的执行一系列事务的效果应该同于并发的执行它们。这要求两件事:

在一个事务执行过程中，数据的中间的(可能不一致)状态不应该被暴露给所有的其他事务。

两个并发的事务应该不能操作同一项数据。数据库管理系统通常使用锁来实现这个特征。

持久性(DURABILITY):
一个被完成的事务的效果应该是持久的。




软件漏洞 操作系统保护模式 进程


C++中sizeof和strlen的区别是什么？
strlen:统计字符的个数。计算字符串长度的函数，返回的是实际串长度。strlen的结果要在运行的时候才能计算出来。
sizeof:统计类型或者变量所占的内存字节数。如果是数据类型，则返回数据类型大小，如果是用数组，则返回数组所占空间大小。sizeof在编译的时候就把计算过。示例，以32位系统为例。
char *str = "hello";
strlen(str); //它的值是5，因为hello这个字符串有5个字符
sizeof(str); //它的值是4，因为char *是一个指针类型，它占4个字节。？
sizeof("hello"); //它的值是5，是因为hello有5个字符，每一个字符占1个字节。

char str[11]="0123456789";//注意这里str大小因该大于等于11，应考虑'\0'在内，否则编译器会报错
int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度，以结束符 0x00 为字符串结束。
int b=sizeof(str); //而b=11; >>>> sizeof 计算的则是分配的数组 str[11] 所占的内存空间的大小，不受里面存储的内容改变。
int a[2] = {0};
sizeof(a); //它的值是8，因为a中有2个int型变量，每个int型占4个字节，所以8字节。
sizeof只看等号左边的，根据数据类型大小来计算。 strlen看等号右边的返回的是实际串长度。
int，在内存中占4个字节 short int 至少16位，也就是2个字节。长整型都是占4个字节



mvc框架
MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。
MVC开始是存在于桌面程序中的，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。[1-2]

模型－视图－控制器（MVC）是Xerox PARC在二十世纪八十年代为编程语言Smalltalk－80发明的一种软件设计模式，已被广泛使用。后来被推荐为Oracle旗下Sun公司Java EE平台的设计模式，并且受到越来越多的使用ColdFusion和PHP的开发者的欢迎。模型－视图－控制器模式是一个有用的工具箱，它有很多好处，但

也有一些缺点
无边图
ping服务器可能的时间 如果是ping网关，一般输入ping 192.168.1.1，看返回的time一般小于2ms，就算是正常了。

进程死锁的必要条件：

产生死锁的原因主要是：
（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则
就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。

产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之
一不满足，就不会发生死锁。

死锁的解除与预防：
理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和
解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确
定资源的合理分配算法，避免进程永久占据系统资源。此外，也要防止进程在处于等待状态
的情况下占用资源。因此，对资源的分配要给予合理的规划。


栈和队列
1.队列先进先出，栈先进后出。
2. 对插入和删除操作的"限定"。 栈是限定只能在表的一端进行插入和删除操作的线性表。 队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。

可将线性表和栈及队列的插入和删除操作对比如下：

线性表
Insert(L,i,x)
(1≤i≤n+1)
Delete(L,i)
(1≤i≤n)
如线性表允许在表内任一位置进行插入和删除

栈
Insert(L,n+1,x)
Delete(L,n)
而栈只允许在表尾一端进行插入和删除

队列
Insert(L,n+1,x)
Delete(L,1)
队列只允许在表尾一端进行插入，在表头一端进行删除

3.遍历数据速度不同。栈只能从头部取数据 也就最先放入的需要遍历整个栈最后才能取出来，而且在遍历数据的时候还得为数据开辟临时空间，保持数据在遍历前的一致性队列怎不同，队列基于地址指针进行遍历，而且可以从头或尾部开始遍历，但不能同时遍历，无需开辟临时空间，因为在遍历的过程中不影像数据结构，速度要快的多。

文件系统最小磁盘空间单位：扇区 或族
一方面，磁盘上的文件存储空间分块越大则每个文件存储后没有使用的空间就越多，存储的效率就越低下；

反过来讲，文件存储空间分块越小则磁盘的利用率越高；另一方面，磁盘上的文件还要经常修改，如果连续排列文件，则当文件长度变化以后，后面的空间很难处理：要继续保持连续就必须移动后面的所有文件，这将耗费许多处理时间同时还会减少磁盘的寿命，其实操作系统提供的碎片整理工具就是在进行这项工作，只不过不是以字节为单位而是以“簇”为单位。因此，将最小的文件存储空间定为“簇”是权衡磁盘存储效率和文件读写的速度等多因素后的结果。

平衡二叉树
平衡二叉树（Balanced Binary Tree）又被称为AVL树，且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用算法有红黑树、AVL、Treap等。在平衡二叉搜索树中，我们可以看到，其高度一般都良好地维持在O（log（n）），大大降低了操作的时间复杂度。 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于一个递归的数列，可以参考Fibonacci数列，1是根节点，F(n-1)是左子树的节点数量，F(n-2)是右子树的节点数量。


取纽扣
有1992颗纽扣,两人从中轮流取几颗,但每人最少取一颗,最多取4颗,谁取到最后一颗,就是胜者.你能保证获胜吗?说说你的克敌对策是?

要保证获胜的话，就是说最后轮到对方取时要剩5颗，
往上推就可以知道前一次轮到对方取时要剩10颗，
这样无论对方取多少（1-4），你都能做到刚好剩5颗，
依次往上推一步，你会发现只要做到轮到对方取时，剩下纽扣的数量为5n颗，
你就能保证获胜。由于1992=(1+4)*398+2,因此,先取者采取的策略是:先取2根纽扣,然后在后取者每次取走1 2 3 4颗纽扣后,先取者相应地取走4 3 2 1颗,使得两人正好共取走5颗纽扣.这样,先取者取走纽扣后,保证留下的正好总是5的倍数,如此取下去,直到桌上的纽扣只有5颗,接着是后取者取走1 2 3 4颗,而剩下的4 3 2 1颗正好被先取者取走,因此,总是先取者胜.

没做完 ，快速做到最后。

格子乘法
例如计算乘积1236×245：

先画一个矩形，把它分成4×3个小格，在小格边上依次写下因数、因数的各位数字，再用对角线把小格一分为二，分别记录上述各位数字相应乘积的十位数与个位数，把这些乘积由右到左，沿斜线方向相加，相加满十时要向前进一。最后得到1236×245=如图所列的答案 302820


哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生

不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法。

哈希(Hash)算法,即散列函数。它是一种单向密码体制,即它是一个从明文到密文的不可逆的映射,只有加密过程,没有解密过程。同时,哈希函数可以将任意长度的输入经过变化以后得到固定长度的输出。哈希函数的这种单向特征和输出数据长度固定的特征使得它可以生成消息或者数据。[
举个更形象点的例子。
这东西其实就像字典（其实就是）。你给出来的字符串是一个单词，他在字典里面所属的条目是A-Z其中一个字母。不管你给的单词有多长，他总属于字典中某一个目录下（也就是首字母。。）。你现在有两个单词，你不知道他们都是什么，但是你知道一个在“A”里面一个在“E”里面。这样你就知道这俩肯定不是同样的单词。不过由于每个条目下都有一大堆的单词，所以你还是不知道这两个单词具体是什么。
虽然这种方法得到的不是原始记录，而仅仅是与之具有相同特征的记录



贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

贪心算法当然也有正确的时候。求最小生成树的Prim算法和Kruskal算法都是漂亮的贪心算法。
贪心法的应用算法有Dijkstra的单源最短路径和Chvatal的贪心集合覆盖启发式
所以需要说明的是，贪心算法可以与随机化算法一起使用，具体的例子就不再多举了。其实很多的智能算法（也叫启发式算法），本质上就是贪心算法和随机化算法结合——这样的算法结果虽然也是局部最优解，但是比单纯的贪心算法更靠近了最优解。例如遗传算法，模拟退火算法。

马踏棋盘的贪心算法

【问题描述】
马的遍历问题。在8×8方格的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。
【初步设计】
首先这是一个搜索问题，运用深度优先搜索进行求解。算法如下：
⒈ 输入初始位置坐标x,y；
⒉ 步骤 c:
如果c> 64输出一个解，返回上一步骤c--
（x,y) ← c
计算(x,y）的八个方位的子结点，选出那些可行的子结点
循环遍历所有可行子结点，步骤c++重复2
显然⑵是一个递归调用的过程，大致如下：
C++程序：

#define N 8
void dfs(int x,int y,int count)
{
int i,tx,ty;
if(count>N*N)
{
output_solution();//输出一个解
return;
}
for(i=0; i<8; i++)
{
tx=hn[i].x;//hn[]保存八个方位子结点
ty=hn[i].y;
s

[tx][ty]=count;
dfs(tx,ty,count+1);//递归调用
s[tx][ty]=0;
}
}

约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。


C语言
递归法：

#include
#include
struct_Node
{
intdata;
struct_Node*next;
};
typedefstruct_Nodenode_t;
typedefstruct_Linklist
{
node_t*phead;
node_t*ptail;
intlen;
}Linklist;
staticnode_t*GetNode(inti)//新建并初始化节点
{
node_t*pNode;
pNode=(node_t*)malloc(sizeof(node_t));
if(!pNode)
{
printf("Error,thememoryisnotenough!\n");
exit(-1);
}
pNode->data=i;
pNode->next=NULL;
returnpNode;
}
voidinit_list(Linklist*plist)//用第一个节点初始化循环单链表
{
node_t*p;
p=GetNode(1);
//printf("TheNewNodeis:%d\n",p->data);//****TEST****
plist->phead=p;
plist->ptail=p;
p->next=plist->phead;
plist->len=1;
}
staticvoidCreate_List(Linklist*plist,intn)//把其余数据添加到循环单链表中
{
inti=0;
node_t*pNew;
for(i=2;i<=n;i++)
{
pNew=GetNode(i);
/********TEST********
printf("TheNewNodeis:%d\n",pNew->data);
********TEST********/
plist->ptail->next=pNew;
plist->ptail=pNew;
pNew->next=plist->phead;
plist->len++;
}
printf("Completesthee-waycirculationchaintablethefoundation!\n");
}
voidPrint_List(Linklist*plist)//输出链表内容
{
node_t*pCur=plist->phead;
do
{
printf("The%dperson.\n",pCur->data);
pCur=pCur->next;
}while(pCur!=plist->phead);
printf("ThelengthoftheList:%d\n",plist->len);
}

约瑟夫回环函数实现

voidjoseph(Linklist*plist,intm)//约瑟夫回环函数实现
{
node_t*pPre=plist->ptail;
node_t*pCur=plist->phead;
inti;
while(plist->len!=1)
{
i=0;
while(i{
pPre=pPre->next;
i++;
}
pCur=pPre->next;
pPre->next=pCur->next;
free(pCur);
plist->len--;
}
printf("Thelastoneis:%d\n",pPre->data);
}
intmain()
{
intn=0;
printf("PleaseinputtheLengthoftheCirclelist:");
scanf("%d",&n);
intm=0;
printf("PleaseinputtheStoppoint:");
scanf("%d",&m);
LinklistpList;
init_list(&pList);
Create_List(&pList,n);
Print_List(&pList);
joseph(&pList,m);
return0;
}




非递归法：

#include
#defineM200
intmain
inttemp=0;
intb=1,k=0;
for(inti=1;i<=M;i++)
temp=b+3*k;
if(i==temp)//规则2：若上一组数字为最后保留号与人数相等，则下一数从2开始记。
b=2;
k=0;
continue;
elseif(i-temp==1）//规则1：若上一组数字为最后保留号比人数少一，则下一数从1开始记。
{b=1;k=0;continue;}
k++;
printf("%d%d",M,temp);
return0;


C++数列推导实现（数学推导式）

#include
#include
using std::cout;
using std::endl;
using std::cin;
using std::list;

int main()
{

int total = 0;
cout << "Please input total number of people : ";
cin >> total;

int number = 0;
cout << "Please input selected number : ";
cin >> number;

/* If number = 3
* f(1) = 0
* f(2) = 1 = (f(1) + 3) % 2
* f(3) = 1 = (f(2) + 3) % 3
* f(4) = 0 = (f(3) + 3) % 4
* f(5) = 3 = (f(4) + 3) % 5
* ...
* f(n) = x = (f(n-1) + 3) % n
* */

int last = 0; // f(1) = 0
for(int i = 2; i <= total; ++i)
{
last = (last + number) % i;
}
cout << "The last one is : " << last + 1 << endl;

return 0;
}




把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，创立了解决这类过程优化问题的新方法——动态规划

用动态规划法求组和数的算法
#include
int combinat(int m, int n) {
int i, j;
int mat;
if (n == 0 || m == n)
return 1;
else {
for (j = 0; j < n; j++) {
mat[j] = 1;
for (i = 1; i <= m-n; i++)
if (j == 0)
mat[i][j] = i+1;
else
mat[i][j] = mat[i-1][j] + mat[i][j-1];
}
return (mat[m-n][n-1]); /* 返回计算得到的结果 */
}
}

int main() {
printf("m=%d ,n=%d ,combinat=%d\n", 10, 2, combinat(10, 2));
printf("m=%d ,n=%d ,combinat=%d\n", 5, 3, combinat(5, 3));
printf("m=%d ,n=%d ,combinat=%d\n", 6, 1, combinat(6, 1));
printf("m=%d ,n=%d ,combinat=%d\n", 4, 2, combinat(4, 2));
return 0;
}


银行家算法

在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。

要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。


五大常用算法：分治、动态规划、贪心算法、回溯算法和分支界定算法

分治法的设计思想是： 将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之 。
动态规划 把多阶段过

程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，创立了解决这类过程优化问题的新方法——动态规划。

动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。 贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。

回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。

分支定界法是一种搜索与迭代的方法，选择不同的分支变量和子问题进行分支。是一种求解整数规划问题的最常用算法


sizeof() 返回该变量类型(variable type) 或对象(object)所占的字节数：


当数据成员中有指针时,必须要用深拷贝

1、扩展了应用程序的特性；

2、可以用许多种编程语言来编写；

3、简化了软件项目的管理；

4、有助于节省内存；

5、有助于资源共享；

6、有助于应用程序的本地化；

7、有助于解决平台差异；

8、可以用于一些特殊的目的。windows使得某些特性只能为DLL所用。




下面哪种排序算法的算法复杂度平均不是O(nlogn)的? 希尓排序

快速排序

桶排序

合并排序

二叉树排序树排序

堆排序

希尓排序




二叉树先顺序 houxu 公务员考试题


在代码工程中为了避免在代码中硬编码我们的数据库连接串或者一些动态的配置，我们往往都会通过配置项文件来管理这些变化的数据。某个文件xxx.properties中有如下示例规范的配置内容，请编写程序，将xxx.properties进行读取并将每一行的键值对和注释进行解析，放入包含key,value,comment的数据结构中。并给出测试用例验证程序的正确性，尤其是在特殊情形下的表现。




















mportjava.io.IOException;
2.importjava.io.InputStream;
3.importjava.util.Properties;
4.
5./**解析xxx.properties文件
6.*并假定使用ISO8859-1字符编码；即每个字节都是Latin1字符
7.*对于非Latin1的字符和某些特殊字符，可以使用Unicode转义以键和元素的形式来表示它们
8.*配置文件格式:
9.*按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）
10.*如：键为Truth，值为Beauty
11.*Tr

uth=Beauty
12.*Truth=Beauty
13.*Truth:Beauty
14.*键为fruits，值为apple,banana,pear,cantaloupe,watermelon,kiwi,mango
15.*fruits:
16.*apple,banana,pear,\
17.*cantaloupe,watermelon,\
18.*kiwi,mango
19.*注释行以ASCII字符'#'或'!'作为开头，不参加解析
20.*@authorguwh
21.*
22.*/
23.publicclassTestParseProperties{
24.privatestaticTestParsePropertiesparseProperties;
25.//获取java.util.Properties类
26.Propertiesproperties=newProperties();
27.
28.privateTestParseProperties(){
29.try{
30.this.parseProp();
31.}catch(Exceptione){
32.e.printStackTrace();
33.}
34.}
35.
36.publicstaticTestParsePropertiesgetInstance(){
37.if(parseProperties==null)
38.parseProperties=newTestParseProperties();
39.returnparseProperties;
40.
41.}
42.
43.
44.publicPropertiesparseProp()throwsIOException{
45./**
46.*Class.getResourceAsStream(Stringname)
47.*查找具有给定名称的资源，return一个InputStream对象
48.*如果找不到带有该名称的资源，则返回null
49.*NullPointerException-如果name是null
50.*/
51.
52./**
53.*配置文件jwt.properties在包.jabberchina.xmppserver.plugin.jwt.vo下
54.InputStreamis=this.getClass().getResourceAsStream("/com/jabberchina/xmppserver/plugin/jwt/vo/jwt.properties");
55.*/
56./**
57.*配置文件jwt.properties1与本类TestParseProperties在同一包目录src.test下
58.InputStreamis=this.getClass().getResourceAsStream("jwt.properties1");
59.*/
60.
61.//配置文件jwt2.properties在包src.test.property下
62.InputStreamis=this.getClass().getResourceAsStream("property/jwt2.properties");
63./**
64.*Properties.load(InputStreaminStream)从输入流中读取属性列表（键和元素对）
65.*IOException-如果读取输入流时发生错误。
66.*IllegalArgumentException-如果输入流包含错误的Unicode转义序列
67.*此方法返回后，指定的流（inStream）仍保持打开状态，所以若不再使用inStream要手动关闭
68.*返回类型void
69.*/
70.properties.load(is);
71.is.close();
72.returnproperties;
73.}
74.
75.publicStringgetProperties(Stringkey){
76./**
77.*用指定的键在此属性列表中搜索属性
78.*如果在此属性列表中未找到该键，则接着递归检查默认属性列表及其默认值,如果未找到属性，则此方法返回null
79.*返回类型String
80.*/
81.returnproperties.getProperty(key);
82.}
83.
84.publicstaticvoidmain(String[]args){
85.Stringkey="dadaPath";
86.Stringrestult=TestParseProperties.getInstance().getProperties(key);
87.System.out.println("protiesvalueis"+restult);
88.}
89.
90.}






import java.util.Properties;
2.import java.io.InputStream;
3.import java.io.IOException;
4.
5./**
6.* 读取Properties文件的例子
7.* File: TestProperties.java
8.* User: leizhimin
9.* Date: 2008-2-15 18:38:40
10.*/
11.public final class TestProperties {
12. private static String param1;
13. private static String p

aram2;
14.
15. static {
16. Properties prop = new Properties();
17. InputStream in = Object.class.getResourceAsStream("/test.properties");
18. try {
19. prop.load(in);
20. param1 = prop.getProperty("initYears1").trim();
21. param2 = prop.getProperty("initYears2").trim();
22. } catch (IOException e)




xxxx.db.url= jdbc:mysql://xxxxxxxx:3306/xxx?characterEncoding=UTF8
ername=abcdef
xxxx.db.password= !@#$%^&*(