2014南京软件工程师(JAVA)亚信笔试题
亚信科技java面试题及答案
亚信科技java面试题及答案亚信科技集团是在美国纳斯达克成功上市的第一家中国高科技企业，亚信科技java的职位面试自然少不了要回答面试题，以下是小编为大家收集到的亚信科技java面试题，希望对大家有帮助!亚信科技java面试题篇1(共30分)1、(14分)在计费系统的预处理程序中，对话单进行格式转换时，需要使用strcpy函数已知strcpy,此函数的原型是char *strcpy(char *strDest, const char *strSrc);其中strDest是目的字符串，strSrc是源字符串。
编写strcpy函数(1)不调用C++/C的字符串库函数，请编写函数 strcpy(2)strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值?2、(16分)在电信业务的后台处理程序中，经常会涉及到处理字符串，除了用char *处理字符串之外，C++还为我们提供了封装了的字符串类string，其本质也是用一个动态数组来保存字符串，类String 的原型为：class String{public:String(const char *str = NULL); // 普通构造函数String(const String &other); // 拷贝构造函数~ String(void); // 析构函数String & operate =(const String &other); // 赋值函数private:char *m_data; // 用于保存字符串};请编写String的上述4个函数普通构造函数、拷贝构造函数、析构函数和赋值函数。
亚信科技java面试题篇2(单选题3分，多选题4分，共32分)在每小题列出的四个备选项中只有1个或2个是符合题目要求的，多选题已用*标识出来，请将其答案填写在题后的括号内，错选或未选均无分。
1、下面这段关于指针和常量的关系的程序哪些是错误的( D ) void f(char * p){chars[]=“HW5,V,0,138****1333”;const char * pc =s; //Apc[3] = ’g’; //Bpc = p; //Cchar * const cp = s;cp[3] = ‘a’; //D}A.const char * pc =s;B.pc[3] = ’g’;C.pc = p;D.cp[3] = ‘a’*2、下列关于函数指针的初始化哪些是错误的?( )A. void reset(int *);void (*pf) (void *) = reset;B. int calc(int ,int );int (*pf1)(int ,int ) =calc;C. extern “c” int compute(int * ,int);int (*pf3)(int *,int) = compute;D. void (*pf4)(const matrix &)=0;3、在计费预处理程序中，取话单函数GetNextCdr的原形类似于int GetNextCdr(StdCdr *pd, int &ri)，变量x和y的定义是StdCdr x; int y，把x和y分别作为第一参数和第二参数来调用函数GetNextCdr，正确的调用语句是( B )A.GetNextCdr (x,&y);B.GetNextCdr (&x,y);C.GetNextCdr (&x,&y);D.GetNextCdr (x,y);4、下列关于结构体的使用哪些是正确的?(C )A. struct StdCdr{char switch[3];int number;StdCdr * next;}B. struct StdCdr{char switch[3];int number;StdCdr next;}C. struct StdCdr{char switch[3];int number;StdCdr * next;};D. StdCdr pStd = new StdCdr;pStd. number = 10;5、对于如下程序#includeclass A{ public:A() {std::cout<<"A"<};int main(){ A a[4], b，*p; }会输出多少个A?( C )A.2B.3C.5D.66、派生类的对象对它的基类成员中哪些是可以访问的?(A.公有继承的成员B.公有继承的私有成员C.公有继承的保护成员D.公有继承的公有成员E.私有继承的公有成员7、下面派生类的虚函数的重新声明哪些是良好的?( )A.Base * Base::copy(Base *);Base * Derived::copy(Derived * );B.Base * Base::copy(Base *);Base * Derived::copy(Base * );C.ostream & Base::print(int,ostream&= cout);ostream & Derived::print(int,ostream&);D.void Base::eval()const; D E )void Derived::eval();* 8、已知下列类层次结构，他们都定义了缺省的构造函数( C D ) class X{ };class A{ };class B: public A{ };class C: private B{ };class D:public X,public C{ };D * pd = new D;对于下列哪些转换是不允许的?A. X * px = pd;B. B * pb = pd;C. A * pa = pd;D. C * pc = pd;9、在对语音话单文件进行取话单字段信息操作时，需要用刀lseek函数，在lseek函数的 (int filedes, off_t offset, int whence)参数中，若whence参数为SEEK_CUR，则offset参数代表下列的哪个含义( B )A.将该文件的位移量设置为距文件开始处offset个字节。
亚信科技java笔试题
亚信科技java笔试题亚信科技Java笔试题参考内容在亚信科技的Java笔试中，可能会涉及到以下几个主题：面向对象编程、异常处理、多线程、集合和泛型、IO流操作等。
以下是对这些主题的详细参考内容。
1. 面向对象编程：面向对象编程是Java的核心概念之一。
面向对象编程的关键特性包括封装、继承和多态。
- 封装：封装是将数据和操作方法封装在一个类中，通过公共的方法来访问和操作数据，隐藏类的内部实现细节。
示例代码：```javapublic class Person {private String name;private int age;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}```- 继承：继承是通过子类继承父类的属性和方法，实现代码的重用和扩展。
子类可以继承父类的公共方法、属性和构造方法。
示例代码：```javapublic class Student extends Person {private String school;public String getSchool() {return school;}public void setSchool(String school) {this.school = school;}}```- 多态：多态是指通过父类的引用变量来调用子类的方法，实现动态绑定。
它可以提高代码的灵活性和重用性。
示例代码：```javapublic class Animal {public void sound() {System.out.println("Animal makes sound");}}public class Dog extends Animal {@Overridepublic void sound() {System.out.println("Dog barks");}}public class Cat extends Animal {@Overridepublic void sound() {System.out.println("Cat meows");}}public class Main {public static void main(String[] args) {Animal animal = new Animal();Animal dog = new Dog();Animal cat = new Cat();animal.sound(); // 输出 "Animal makes sound" dog.sound(); // 输出 "Dog barks"cat.sound(); // 输出 "Cat meows"}}```2. 异常处理：在Java中，异常处理是通过try-catch语句块来实现的。
亚信笔试题B卷以及答案修订稿
亚信笔试题B卷以及答案WEIHUA system office room 【WEIHUA 16H-WEIHUA WEIHUA8Q8-亚信联创科技校园招聘B卷考试时间 60_分钟 _ 考试方式（闭）卷第一部分——计算机基础一、选择题（每题2分，总分40分）1.CPU状态分为目态和管态两种,什么是从目态转换到管态的唯一途径 ( D )A.运行进程修改程序状态字B.进程调度程序C.中断屏蔽D.中断2.引入多道程序设计的目的是( C )A.增强系统的用户友好性B.提高系统实用性C.充分利用CPUD. 扩充内存容量3.Windows系统是一个（B ）操作系统。
A、单用户单系统B、单用户多任务C、多用户单任务D、多用户多任务4.在半导体存储器中，动态随机存储器DRAM的特点是（D ）。
A、按位结构方式存储B、按字结构方式储存C、信息在储存介质中移动D、每隔一定时间进行一次刷新5.单地址指令的格式是由（ B）构成。
A、操作码和操作数地址B、操作码和原操作数地址C、操作码和目的操作数地址D、操作码和下一条指令地址6.八进制数76转换为二进制数为（C ）A、110111B、111101C、111110D、1111117.80486型号的微处理器能同时处理的二进制位数是（C ）位。
A、8B、16C、32D、648.下面关于串的的叙述中，哪一个是不正确的（B ）A．串是字符的有限序列B．空串是由空格构成的串C．模式匹配是串的一种重要运算D．串既可以采用顺序存储，也可以采用链式存储9.若串S1=‘ABCDEFG’, S2=‘9898’ ,S3=‘###’,S4=‘012345’,执行concat(replace(S1,substr(S1,length(S2),length(S3)),S3),substr(S4,index(S2,‘8’),length(S2)))其结果为（）A．ABC###G0123B．ABCD###2345C．ABC###G1234D．ABCD###123410.设有两个串p 和q，其中q 是p 的子串，求q 在p 中首次出现的位置的算法称为（C ）A．求子串 B．联接 C．匹配 D．求串长11. 下列字符中，ASCII码值最大的是 ( D )。
2014年亚信联创校园招聘-A卷
亚信联创科技校园招聘A卷考试时间60_分钟_ 考试方式（闭）卷第一部分——计算机基础一、选择题（含单选题和多选题，每题2分，总分40分）1.操作系统的作用是( )。
A．把源程序翻译成目标程序B．进行数据处理C．控制和管理系统资源的使用D．实现软硬件的转换2.计算机软件是指( ) 。
A．计算机程序B．源程序和目标程序C．源程序D．计算机程序及有关资料3. 采用段式存储管理的系统中，若地址用24位表示，其中8位表示段号，则允许每段的最大长度是( )。
A．224B．216C．28D．2324.某系统采用了银行家的算法，则下列叙述正确的是( ) 。
A．系统处于不安全状态时一定会发生死锁B．系统处于不安全状态时可能会发生死锁C．系统处于安全状态时可能会发生死锁D．系统处于安全状态时一定会发生死锁5.当一个进程处于( ) 状态时，称其为等待（或阻塞）状态。
A．它正等待中央处理器B．它正等待合作进程的一个消息C．它正等待分给它一个时间片D．它正等待进入内存6.SPOOLing技术可以实现设备的( ) 分配。
A．独占B．共享C．虚拟D．物理7. 一个算法应该是( )。
A．程序B．问题求解步骤的描述C．要满足五个基本属性D．A和C8. 从一个长度为n的顺序表中删除第i个元素（1<=i<=n）时，需向前移动的元素的个数是( )。
A．n-i B．n-i+1 C．n-i-1 D．i9. 计算机的软件系统一般分为( ) 两大部分。
A．系统软件和应用软件B．操作系统和计算机语言C．程序和数据D．DOS和WINDOWS10.在计算机内部，不需要编译计算机就能直接执行的语言是( )。
A．汇编语言B．自然语言C．机器语言D．高级语言11.下列有可能是八进制数的是( )。
A．488 B．317 C．597 D．18912.计算机病毒是一种( )。
A．计算机命令B．人体病毒C．计算机程序D．外部程序13.下列关于UNIX操作系统的叙述中，不正确的是( )。
亚信校招笔试题目
1.BSTpublic class BSTMinLength {public static void main(String[] args) {TreeNode tNode11 = new TreeNode(10, null, null);TreeNode tNode12 = new TreeNode(50, null, null);TreeNode tNode13 = new TreeNode(5, null, null);TreeNode tNode14 = new TreeNode(30, null, null);TreeNode tNode21 = new TreeNode(30, tNode11, tNode12);TreeNode tNode22 = new TreeNode(30, tNode13, tNode14);TreeNode tNodeRoot = new TreeNode(100, tNode21, tNode22); System.out.println(minlength(tNodeRoot));}private static int minlength(TreeNode tNode){if (tNode != null) {return getlength(tNode,0);}return -1;}private static int getlength(TreeNode tNode,int curLength) {int minLeft=-1;int minRight=-1;if (tNode.leftNode!=null){minLeft=getlength(tNode.leftNode, curLength+tNode.value); }if (tNode.rightNode!=null) {minRight=getlength(tNode.rightNode, curLength+tNode.value); }if (tNode.leftNode==null && tNode.rightNode==null) {return curLength+tNode.value;}if (tNode.leftNode==null) {return minRight;}if (tNode.rightNode==null) {return minLeft;}return minLeft>minRight? minRight:minLeft;}}class TreeNode {int value;TreeNode leftNode;TreeNode rightNode;TreeNode(int value, TreeNode lefeNode, TreeNode rightNode) { this.value = value;this.leftNode = lefeNode;this.rightNode = rightNode;}}2.lru#include <iostream>using namespace std;int lruCountMiss(int max_cache_size, int *pages, int len){int count = 0;int i,j,k,n;bool flag = false;int *a = new int[max_cache_size];//初始化高速缓存数组for(i = 0; i < max_cache_size; i++){a[i] = -1;}for(j= 0; j < len; j++){for(i = 0; i < max_cache_size; i++){if(pages[j] != a[i]){continue;}else{break;}}if(i != max_cache_size){for(k = i; k < max_cache_size; k++) {if(a[k] == -1){flag = true;break;}}if(!flag){for(n = i; n < max_cache_size - 1; n++) {a[n] = a[n+1];}a[max_cache_size - 1] = pages[j];}else{flag = false;for(n = i; n < k - 1; n++){a[n] = a[n+1];}a[k - 1] = pages[j];}}else{count ++;for(i = 0; i < max_cache_size; i++){if(a[i] == -1){a[i] = pages[j];flag = true;break;}}if(!flag){for(i = 0; i < max_cache_size-1; i++) {a[i] = a[i+ 1];}a[max_cache_size - 1] = pages[j];}elseflag = false;}}return count;}int main(){int arr[] = {7, 0, 1, 2, 0, 3, 0, 4};cout << lruCountMiss(3, arr, 8) << endl; return 0;}3.反转链表lnode *reverse(lnode *head){if(head){lnode *prev = NULL;lnode *curr = head;lnode *next = curr->next;curr->next = prev;while(next != NULL){prev = curr;curr = next;next = next->next;curr->next = prev;}return curr;}else{return head;}};lnode *reverseLinkedList(lnode *list){if(list){lnode *ori = list;lnode *half = list;lnode *prev = list;while(list && half && half->next){prev = list;list = list->next;half = half->next;if(half){half = half->next;}}if(list){prev->next = reverse(list);}return ori;}return list;}4. SJFfloat waitingTimeSJF(int * requestTimes, int * durations,int n){int *flags = new int[n];float sums = 0;for(int i = 0 ;i< n; i++){flags[i] = -1;}int nowtime = 0;for( int i = 0; i< n; i++ ){int count = 0;for(int k = 0; k< n;k++){if(count == 0){if(requestTimes[k] <= nowtime && durations[k] >=0 ){ flags[count++] = k;}}else{if(durations[k] >=0 && requestTimes[k] <= nowtime ){ if( durations[k] < durations[flags[0]]){count = 1;flags[0] = k;}else if( durations[k] == durations[flags[0]] ){ flags[count++] = k;}}}}if(count == 0){count = 1;for(int j = 0; j< n ;j++){if(durations[j] >=0 ){flags[0] = j;nowtime = requestTimes[j];}}}int idx = flags[0];int minreq = requestTimes[ flags[0] ];int mindrus = durations[idx];if(count > 1){for(int j = 1; j < count ;j++){if(requestTimes[flags[j]] < minreq ){minreq =requestTimes[flags[j]];idx = flags[j];}}}sums += nowtime - requestTimes[idx];nowtime += durations[idx];requestTimes[idx] = -1;durations[idx] = -1;}return sums/n;}5 无向连通判断是否为树#include<stdio.h>#include<stdlib.h>#include<string.h>const int N=10000, M=100000;bool edge[N][N]; // 数组记录两点是否存在边bool visit[N]; // 标记该节点是否访问过bool DFS_check(int x, int y=-1){if (visit[x])return false;visit[x] = true;int i;for (i=0;i<N;i++)if (edge[x][i] && i!=y)if (visit[i])return false;elseif (!DFS_check(i, x))return false;return true;}int main(){int n,m;scanf("%d%d",&n,&m);memset(edge,false,sizeof(edge)); int i,x,y;for (i=0;i<m;i++){scanf("%d%d",&x,&y);edge[x-1][y-1] = true;edge[y-1][x-1] = true;}memset(visit,false,sizeof(visit)); bool result = DFS_check(0);if (result)for (i=0;i<n;i++)if (!visit[i])result = false;if (result)printf("Yes!\n");elseprintf("No!\n");system("pause");return 0;}6. 老鼠奶酪#include <iostream>using namespace std;int isPath(int **grid, int m, int n);struct _TraversedNode{int x;int y;_TraversedNode *next;};struct _Node{int x;int y;};int main(int argc, const char * argv[]) {int **grid= new int*[8];for(int i=0;i<8;i++){grid[i]= new int[8];}grid[0][0]=1; grid[0][1]=1; grid[0][2]=0; grid[0][3]=0; grid[0][4]=0; grid[0][5]=0; grid[0][6]=0; grid[0][7]=1;grid[1][0]=1; grid[1][1]=1; grid[1][2]=1; grid[1][3]=1; grid[1][4]=1; grid[1][5]=1; grid[1][6]=1; grid[1][7]=1;grid[2][0]=1; grid[2][1]=0; grid[2][2]=0; grid[2][3]=0; grid[2][4]=1; grid[2][5]=0; grid[2][6]=0; grid[2][7]=1;grid[3][0]=1; grid[3][1]=1; grid[3][2]=1; grid[3][3]=0; grid[3][4]=1; grid[3][5]=0; grid[3][6]=0; grid[3][7]=1;grid[4][0]=0; grid[4][1]=1; grid[4][2]=0; grid[4][3]=0; grid[4][4]=1; grid[4][5]=1; grid[4][6]=1; grid[4][7]=1;grid[5][0]=0; grid[5][1]=1; grid[5][2]=0; grid[5][3]=0; grid[5][4]=0; grid[5][5]=0; grid[5][6]=0; grid[5][7]=1;grid[6][0]=0; grid[6][1]=1; grid[6][2]=0; grid[6][3]=9; grid[6][4]=1; grid[6][5]=1; grid[6][6]=1; grid[6][7]=1;grid[7][0]=0; grid[7][1]=1; grid[7][2]=1; grid[7][3]=1; grid[7][4]=0; grid[7][5]=0; grid[7][6]=1; grid[7][7]=0;for(int i=0;i<8;i++){for(int j=0;j<8;j++)cout<<grid[i][j]<<" ";;cout<<endl;}return isPath(grid,8,8);}int isPath(int **grid, int m, int n){if(grid[0][0]==0) return 0;if(grid[0][0]==9) return 1;int step=0;bool flag_down_success=true;bool flag_up_success=true;bool flag_left_success=true;bool flag_right_success=true;_TraversedNode *p=NULL;_TraversedNode *p_check=NULL;_TraversedNode *head=NULL;_TraversedNode *TraversedNode = new _TraversedNode;TraversedNode->x=0;TraversedNode->y=0;head=TraversedNode;p=TraversedNode;p->next=NULL;int count_node=0;int num_node=1;_Node *node=new _Node[n+m];_Node *node_next=new _Node[n+m];node[0].x=0;node[0].y=0;while(1){for(int i=0;i<num_node;i++){if(node[i].x+1<=m-1){if(grid[node[i].x+1][node[i].y]!=0){if(grid[node[i].x+1][node[i].y]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl;return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x+1)&&(p_check->y==node[i].y)) {p_check=NULL;flag_down_success=false;}else{p_check=p_check->next;}}if(flag_down_success){TraversedNode=new _TraversedNode;TraversedNode->x=node[i].x+1;TraversedNode->y=node[i].y;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x+1;node_next[count_node].y=node[i].y;count_node++;}flag_down_success=true;}}if(node[i].x-1>=0){if(grid[node[i].x-1][node[i].y]!=0){if(grid[node[i].x-1][node[i].y]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl;return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x-1)&&(p_check->y==node[i].y)) {p_check=NULL;flag_up_success=false;}else{p_check=p_check->next;}}if(flag_up_success){TraversedNode=new _TraversedNode;TraversedNode->x=node[i].x-1;TraversedNode->y=node[i].y;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x-1;node_next[count_node].y=node[i].y;count_node++;}flag_up_success=true;}}if(node[i].y+1<=n-1){if(grid[node[i].x][node[i].y+1]!=0){if(grid[node[i].x][node[i].y+1]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl; return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x)&&(p_check->y==node[i].y+1)) {p_check=NULL;flag_right_success=false;}else{p_check=p_check->next;}}if(flag_right_success){TraversedNode=new _TraversedNode;TraversedNode->x=node[i].x;TraversedNode->y=node[i].y+1;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x;node_next[count_node].y=node[i].y+1;count_node++;}flag_right_success=true;}}if(node[i].y-1>=0){if(grid[node[i].x][node[i].y-1]!=0){if(grid[node[i].x][node[i].y-1]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl;return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x)&&(p_check->y==node[i].y-1)) {p_check=NULL;flag_left_success=false;}else{p_check=p_check->next;}}if(flag_left_success){TraversedNode=new _TraversedNode;TraversedNode->x=node[i].x;TraversedNode->y=node[i].y-1;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x; node_next[count_node].y=node[i].y-1; count_node++;}flag_left_success=true;}}}if(count_node==0){cout<<"不存在到达终点的路径"<<endl;return 0;break;}step++;num_node=count_node;count_node=0;for(int i=0;i<num_node;i++){node[i].x=node_next[i].x;node[i].y=node_next[i].y;cout<<"("<<node[i].x<<","<<node[i].y<<") "; }cout<<endl;}}7．格雷码import java.util.Scanner;public static int gray(byte term1,byte term2){int n=0;for(int i=0;i<8;i++){byte t1,t2,ch;ch=(byte)0x01;t1=term1&ch;t2=term2&ch;if((t1^t2)==ch){n++;}term1=(byte)(term1>>1);term2=(byte)(term>>1);}if(n==1)return1;elsereturn0;}8.#include <iostream>using namespace std;void myPrint(int n){if(1 == n){cout << "1*2" <<endl;return;}int lastnumber = n*(n+1);//每一行最后一个数int first=1;//每一行第一个数int num=1;int step=n;for(int i=1;i<=n;i++){for(int j=1;j<i;j++)//输出‘-’cout<<'-';num = first;for(int l=0;l<(n-i+1);l++)//每一行的前半部分{cout << num << "*";num++;}num = lastnumber - step+1;cout << num ;num++;for( l=0;l<(n-i);l++)//每一行的后半部分{cout << "*"<<num;num++;}cout << endl;//修改first和lastnumberfirst = first+step;lastnumber = lastnumber - step;step--;}}int main(){int n;while(cin>>n){myPrint(n);}return 0;}9短作业优先调度算法（SJF）public class ShortJobFirst {public static void main(String[] args) {int[] requestTimes = {0, 2, 4, 5};int[] durations = {7, 4, 1, 4};float averageWaitingTime = ShortJobFirst.minWaitingTime(requestTimes, durations);System.out.println(averageWaitingTime);}/**** param requestTimes 任务提交时间* param durations 任务服务时间* return*/public static float minWaitingTime(int[] requestTimes, int[] durations) {if(requestTimes == null || durations == null)return -1;if(requestTimes.length != durations.length)return -1;int n = requestTimes.length;int[] durationTimes = copyArray(durations); // 复制一份服务时间int[] startTimes = new int[n]; // 开始时间int[] endTime = new int[n]; // 结束时间int[] waitingTime = new int[n]; // 等待时间int[] cycleTime = new int[n]; // 周转时间// 第一个执行任务的开始时间、结束时间、等待时间startTimes[0] = requestTimes[0];endTime[0] = startTimes[0] + durations[0];waitingTime[0] = 0;/** 核心代码 **/int lastIndex = 0; // 上一次执行任务的索引int minIndex = 0; // 最短任务的索引for(int i = 1; i < n; i++) {minIndex = getMinIndex(durations); // 作曲最短任务索引为当前任务startTimes[minIndex] = endTime[lastIndex]; // 当前任务的开始时间为上一个任务的结束时间endTime[minIndex] = startTimes[minIndex] + durationTimes[minIndex]; // 结束时间 = 开始时间 + 服务时间waitingTime[minIndex] = startTimes[minIndex] - requestTimes[minIndex]; // 等待时间 = 开始时间 - 提交时间cycleTime[minIndex] = endTime[minIndex] - requestTimes[minIndex]; // 周转时间 = 结束时间 - 提交时间lastIndex = minIndex; // 更新当前任务索引为下一次循环中的“上一次任务索引”}// 计算平均等待时间int s = 0;for(int i : waitingTime)s += i;float averageTime = (float) s / (float) n;return averageTime;}// 获取最短任务索引，获取完成之后，该任务的服务时间置为最大值，从下一次寻找最短任务的过程中排除。
亚信笔试题正常-推荐下载
7、 下列的哪个选项可以正确表达八进制 8 C A 0x8 B 0x10 C 08
11、Given: F 1 public class Alphal{ 2 public static void main(String[] args){ 3 boolean flag; int i=0; 1 do{ 2 flag = false; 3 system.out.println(i++); 4 flag = 1 < 10 5 continue; 6 }while((flag)?True;false); 7} 8}
对全部高中资料试卷电气设备，在安装过程中以及安装结束后进行高中资料试卷调整试验；通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关，系电通，力1根保过据护管生高线产中0不工资仅艺料可高试以中卷解资配决料置吊试技顶卷术层要是配求指置，机不对组规电在范气进高设行中备继资进电料行保试空护卷载高问与中题带资2负料2，荷试而下卷且高总可中体保资配障料置各试时类卷，管调需路控要习试在题验最到；大位对限。设度在备内管进来路行确敷调保设整机过使组程其高1在中正资，常料要工试加况卷强下安看与全22过，22度并22工且22作尽22下可护都能1关可地于以缩管正小路常故高工障中作高资；中料对资试于料卷继试连电卷接保破管护坏口进范处行围理整，高核或中对者资定对料值某试，些卷审异弯核常扁与高度校中固对资定图料盒纸试位，卷置编工.写况保复进护杂行层设自防备动腐与处跨装理接置，地高尤线中其弯资要曲料避半试免径卷错标调误高试高等方中，案资要，料求编试技5写、卷术重电保交要气护底设设装。备备置管4高调、动线中试电作敷资高气，设料中课并技3试资件且、术卷料中拒管试试调绝路包验卷试动敷含方技作设线案术，技槽以来术、及避管系免架统不等启必多动要项方高方案中式；资，对料为整试解套卷决启突高动然中过停语程机文中。电高因气中此课资，件料电中试力管卷高壁电中薄气资、设料接备试口进卷不行保严调护等试装问工置题作调，并试合且技理进术利行，用过要管关求线运电敷行力设高保技中护术资装。料置线试做缆卷到敷技准设术确原指灵则导活：。。在对对分于于线调差盒试动处过保，程护当中装不高置同中高电资中压料资回试料路卷试交技卷叉术调时问试，题技应，术采作是用为指金调发属试电隔人机板员一进，变行需压隔要器开在组处事在理前发；掌生同握内一图部线纸故槽资障内料时，、，强设需电备要回制进路造行须厂外同家部时出电切具源断高高习中中题资资电料料源试试，卷卷线试切缆验除敷报从设告而完与采毕相用，关高要技中进术资行资料检料试查，卷和并主检且要测了保处解护理现装。场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况，然后根据规范与规程规定，制定设备调试高中资料试卷方案。
亚信校招笔试题目
public class BSTMinLength {public static void main(String[] args) {TreeNode tNode11 = new TreeNode(10, null, null);TreeNode tNode12 = new TreeNode(50, null, null);TreeNode tNode13 = new TreeNode(5, null, null);TreeNode tNode14 = new TreeNode(30, null, null);TreeNode tNode21 = new TreeNode(30, tNode11, tNode12);TreeNode tNode22 = new TreeNode(30, tNode13, tNode14);TreeNode tNodeRoot = new TreeNode(100, tNode21, tNode22); System.out.println(minlength(tNodeRoot));}private static int minlength(TreeNode tNode){if (tNode != null) {return getlength(tNode,0);}return -1;}private static int getlength(TreeNode tNode,int curLength) {int minLeft=-1;int minRight=-1;if (tNode.leftNode!=null){minLeft=getlength(tNode.leftNode, curLength+tNode.value); }if (tNode.rightNode!=null) {minRight=getlength(tNode.rightNode, curLength+tNode.value); }if (tNode.leftNode==null && tNode.rightNode==null) {return curLength+tNode.value;if (tNode.leftNode==null) {return minRight;}if (tNode.rightNode==null) {return minLeft;}return minLeft>minRight? minRight:minLeft;}}class TreeNode {int value;TreeNode leftNode;TreeNode rightNode;TreeNode(int value, TreeNode lefeNode, TreeNode rightNode) { this.value = value;this.leftNode = lefeNode;this.rightNode = rightNode;}}2.lru#include <iostream>using namespace std;int lruCountMiss(int max_cache_size, int *pages, int len){int count = 0;int i,j,k,n;bool flag = false;int *a = new int[max_cache_size];//初始化高速缓存数组for(i = 0; i < max_cache_size; i++){a[i] = -1;}for(j= 0; j < len; j++){for(i = 0; i < max_cache_size; i++){if(pages[j] != a[i]){continue;}else{break;}}if(i != max_cache_size){for(k = i; k < max_cache_size; k++){if(a[k] == -1){flag = true;break;}}if(!flag){for(n = i; n < max_cache_size - 1; n++)a[n] = a[n+1];}a[max_cache_size - 1] = pages[j];}else{flag = false;for(n = i; n < k - 1; n++){a[n] = a[n+1];}a[k - 1] = pages[j];}}else{count ++;for(i = 0; i < max_cache_size; i++){if(a[i] == -1){a[i] = pages[j];flag = true;break;}}if(!flag){for(i = 0; i < max_cache_size-1; i++)a[i] = a[i+ 1];}a[max_cache_size - 1] = pages[j]; }elseflag = false;}}return count;}int main(){int arr[] = {7, 0, 1, 2, 0, 3, 0, 4};cout << lruCountMiss(3, arr, 8) << endl; return 0;}3.反转链表lnode *reverse(lnode *head){if(head){lnode *prev = NULL;lnode *curr = head;lnode *next = curr->next;curr->next = prev;while(next != NULL){prev = curr;curr = next;next = next->next;curr->next = prev;}return curr;}else{return head;}};lnode *reverseLinkedList(lnode *list){if(list){lnode *ori = list;lnode *half = list;lnode *prev = list;while(list && half && half->next){prev = list;list = list->next;half = half->next;if(half){half = half->next;}}if(list){prev->next = reverse(list);}return ori;}return list;}4. SJFfloat waitingTimeSJF(int * requestTimes, int * durations,int n){ int *flags = new int[n];float sums = 0;for(int i = 0 ;i< n; i++){flags[i] = -1;}int nowtime = 0;for( int i = 0; i< n; i++ ){int count = 0;for(int k = 0; k< n;k++){if(count == 0){if(requestTimes[k] <= nowtime && durations[k] >=0 ){ flags[count++] = k;}}else{if(durations[k] >=0 && requestTimes[k] <= nowtime ){ if( durations[k] < durations[flags[0]]){count = 1;flags[0] = k;}else if( durations[k] == durations[flags[0]] ){flags[count++] = k;}}}}if(count == 0){count = 1;for(int j = 0; j< n ;j++){if(durations[j] >=0 ){flags[0] = j;nowtime = requestTimes[j];}}}int idx = flags[0];int minreq = requestTimes[ flags[0] ];int mindrus = durations[idx];if(count > 1){for(int j = 1; j < count ;j++){if(requestTimes[flags[j]] < minreq ){ minreq =requestTimes[flags[j]]; idx = flags[j];}}}sums += nowtime - requestTimes[idx];nowtime += durations[idx];requestTimes[idx] = -1;durations[idx] = -1;}return sums/n;}5 无向连通判断是否为树#include<stdio.h>#include<stdlib.h>#include<string.h>const int N=10000, M=100000;bool edge[N][N]; // 数组记录两点是否存在边bool visit[N]; // 标记该节点是否访问过bool DFS_check(int x, int y=-1) {if (visit[x])return false;visit[x] = true;int i;for (i=0;i<N;i++)if (edge[x][i] && i!=y)if (visit[i])return false;elseif (!DFS_check(i, x))return false;return true;}int main(){int n,m;scanf("%d%d",&n,&m);memset(edge,false,sizeof(edge)); int i,x,y;for (i=0;i<m;i++){scanf("%d%d",&x,&y);edge[x-1][y-1] = true;edge[y-1][x-1] = true;}memset(visit,false,sizeof(visit)); bool result = DFS_check(0);if (result)for (i=0;i<n;i++)if (!visit[i])result = false;if (result)printf("Yes!\n");elseprintf("No!\n");system("pause");return 0;}6. 老鼠奶酪#include <iostream>using namespace std;int isPath(int **grid, int m, int n);struct _TraversedNode{int x;int y;_TraversedNode *next;};struct _Node{int x;int y;};int main(int argc, const char * argv[]){int **grid= new int*[8];for(int i=0;i<8;i++){grid[i]= new int[8];}grid[0][0]=1; grid[0][1]=1; grid[0][2]=0; grid[0][3]=0; grid[0][4]=0; grid[0][5]=0; grid[0][6]=0; grid[0][7]=1;grid[1][0]=1; grid[1][1]=1; grid[1][2]=1; grid[1][3]=1; grid[1][4]=1; grid[1][5]=1; grid[1][6]=1; grid[1][7]=1;grid[2][0]=1; grid[2][1]=0; grid[2][2]=0; grid[2][3]=0; grid[2][4]=1; grid[2][5]=0; grid[2][6]=0; grid[2][7]=1;grid[3][0]=1; grid[3][1]=1; grid[3][2]=1; grid[3][3]=0; grid[3][4]=1; grid[3][5]=0; grid[3][6]=0; grid[3][7]=1;grid[4][0]=0; grid[4][1]=1; grid[4][2]=0; grid[4][3]=0; grid[4][4]=1; grid[4][5]=1; grid[4][6]=1; grid[4][7]=1;grid[5][0]=0; grid[5][1]=1; grid[5][2]=0; grid[5][3]=0; grid[5][4]=0; grid[5][5]=0; grid[5][6]=0; grid[5][7]=1;grid[6][0]=0; grid[6][1]=1; grid[6][2]=0; grid[6][3]=9; grid[6][4]=1; grid[6][5]=1; grid[6][6]=1; grid[6][7]=1;grid[7][0]=0; grid[7][1]=1; grid[7][2]=1; grid[7][3]=1; grid[7][4]=0; grid[7][5]=0; grid[7][6]=1; grid[7][7]=0;for(int i=0;i<8;i++){for(int j=0;j<8;j++)cout<<grid[i][j]<<" ";;cout<<endl;}return isPath(grid,8,8);}int isPath(int **grid, int m, int n){if(grid[0][0]==0) return 0;if(grid[0][0]==9) return 1;int step=0;bool flag_down_success=true;bool flag_up_success=true;bool flag_left_success=true;bool flag_right_success=true;_TraversedNode *p=NULL;_TraversedNode *p_check=NULL;_TraversedNode *head=NULL;_TraversedNode *TraversedNode = new _TraversedNode;TraversedNode->x=0;TraversedNode->y=0;head=TraversedNode;p=TraversedNode;p->next=NULL;int count_node=0;int num_node=1;_Node *node=new _Node[n+m];_Node *node_next=new _Node[n+m];node[0].x=0;node[0].y=0;while(1){for(int i=0;i<num_node;i++){if(node[i].x+1<=m-1){if(grid[node[i].x+1][node[i].y]!=0){if(grid[node[i].x+1][node[i].y]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl;return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x+1)&&(p_check->y==node[i].y)) {p_check=NULL;flag_down_success=false;}else{p_check=p_check->next;}}if(flag_down_success){TraversedNode=new _TraversedNode;TraversedNode->x=node[i].x+1;TraversedNode->y=node[i].y;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x+1;node_next[count_node].y=node[i].y;count_node++;}flag_down_success=true;}}if(node[i].x-1>=0){if(grid[node[i].x-1][node[i].y]!=0){if(grid[node[i].x-1][node[i].y]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl;return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x-1)&&(p_check->y==node[i].y)) {p_check=NULL;flag_up_success=false;}else{p_check=p_check->next;}}if(flag_up_success){TraversedNode=new _TraversedNode; TraversedNode->x=node[i].x-1;TraversedNode->y=node[i].y;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x-1; node_next[count_node].y=node[i].y; count_node++;}flag_up_success=true;}}if(node[i].y+1<=n-1){if(grid[node[i].x][node[i].y+1]!=0){if(grid[node[i].x][node[i].y+1]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl;return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x)&&(p_check->y==node[i].y+1)) {p_check=NULL;flag_right_success=false;}else{p_check=p_check->next;}}if(flag_right_success){TraversedNode=new _TraversedNode;TraversedNode->x=node[i].x;TraversedNode->y=node[i].y+1;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x;node_next[count_node].y=node[i].y+1;count_node++;}flag_right_success=true;}}if(node[i].y-1>=0){if(grid[node[i].x][node[i].y-1]!=0){if(grid[node[i].x][node[i].y-1]==9){step++;cout<<"可以最短"<<step<<"步到达终点"<<endl;return 1;}p_check=head;while(p_check!=NULL){if((p_check->x==node[i].x)&&(p_check->y==node[i].y-1)) {p_check=NULL;flag_left_success=false;}else{p_check=p_check->next;}}if(flag_left_success){TraversedNode=new _TraversedNode;TraversedNode->x=node[i].x;TraversedNode->y=node[i].y-1;p->next=TraversedNode;p=TraversedNode;p->next=NULL;node_next[count_node].x=node[i].x; node_next[count_node].y=node[i].y-1; count_node++;}flag_left_success=true;}}}if(count_node==0){cout<<"不存在到达终点的路径"<<endl;return 0;break;}step++;num_node=count_node;count_node=0;for(int i=0;i<num_node;i++){node[i].x=node_next[i].x;node[i].y=node_next[i].y;cout<<"("<<node[i].x<<","<<node[i].y<<") "; }cout<<endl;}}7．格雷码import java.util.Scanner;public static int gray(byte term1,byte term2){int n=0;for(int i=0;i<8;i++){byte t1,t2,ch;ch = (byte)0x01;t1=term1&ch;t2=term2&ch;if((t1^t2)==ch){n++;}term1=(byte)(term1>>1);term2=(byte)(term>>1);}if(n==1)return 1;elsereturn0;}8.#include <iostream>using namespace std;void myPrint(int n){if(1 == n){cout << "1*2" <<endl;return;}int lastnumber = n*(n+1);//每一行最后一个数int first=1;//每一行第一个数int num=1;int step=n;for(int i=1;i<=n;i++){for(int j=1;j<i;j++)//输出‘-’cout<<'-';num = first;for(int l=0;l<(n-i+1);l++)//每一行的前半部分{cout << num << "*";num++;}num = lastnumber - step+1;cout << num ;num++;for( l=0;l<(n-i);l++)//每一行的后半部分{cout << "*"<<num;num++;}cout << endl;//修改first和lastnumberfirst = first+step;lastnumber = lastnumber - step;step--;}}int main(){int n;while(cin>>n){myPrint(n);}return 0;}9短作业优先调度算法（SJF）public class ShortJobFirst {public static void main(String[] args) {int[] requestTimes = {0, 2, 4, 5};int[] durations = {7, 4, 1, 4};float averageWaitingTime = ShortJobFirst.minWaitingTime(requestTimes, durations);System.out.println(averageWaitingTime);}/**** @param requestTimes 任务提交时间* @param durations 任务服务时间* @return*/public static float minWaitingTime(int[] requestTimes, int[] durations) {if(requestTimes == null || durations == null)return -1;if(requestTimes.length != durations.length)return -1;int n = requestTimes.length;int[] durationTimes = copyArray(durations); // 复制一份服务时间int[] startTimes = new int[n]; // 开始时间int[] endTime = new int[n]; // 结束时间int[] waitingTime = new int[n]; // 等待时间int[] cycleTime = new int[n]; // 周转时间// 第一个执行任务的开始时间、结束时间、等待时间startTimes[0] = requestTimes[0];endTime[0] = startTimes[0] + durations[0];waitingTime[0] = 0;/** 核心代码 **/int lastIndex = 0; // 上一次执行任务的索引int minIndex = 0; // 最短任务的索引for(int i = 1; i < n; i++) {minIndex = getMinIndex(durations); // 作曲最短任务索引为当前任务startTimes[minIndex] = endTime[lastIndex]; // 当前任务的开始时间为上一个任务的结束时间endTime[minIndex] = startTimes[minIndex] + durationTimes[minIndex]; // 结束时间 = 开始时间 + 服务时间waitingTime[minIndex] = startTimes[minIndex] - requestTimes[minIndex]; // 等待时间 = 开始时间 - 提交时间cycleTime[minIndex] = endTime[minIndex] - requestTimes[minIndex]; // 周转时间 = 结束时间 - 提交时间lastIndex = minIndex; // 更新当前任务索引为下一次循环中的“上一次任务索引”}// 计算平均等待时间int s = 0;for(int i : waitingTime)s += i;float averageTime = (float) s / (float) n;return averageTime;}// 获取最短任务索引，获取完成之后，该任务的服务时间置为最大值，从下一次寻找最短任务的过程中排除。
2014年下半年下午 程序员 试题及答案与解析-软考考试真题-案例分析
2014年下半年下午程序员考试试题-案例分析-答案与解析试题一（共15分）阅读以下说明和流程图，填补流程图中的空缺（1)〜（5)，将解答填入答题纸的对应栏内。
【说明】本流程图旨在统计一本电子书中各个关键词出现的次数。
假设已经对该书从头到尾依次分离出各个关键词{A(i)|i=1，…，n}(n>1) }，其中包含了很多重复项，经下面的流程处理后，从中挑选出所有不同的关键词共m个{K(j)lj=l，…，m}，而每个关键词K(j)出现的次数为K(j)，j=1,…，m。
【流程图】【参考答案】(1)、1(2)、K(j)(3)、NK(j)+1->NK(j) 或NK(j)++ 或等价表示(4)、m+1->m 或m++ 或等价表示(5)、A(i)【答案解析】流程图中的第1框显然是初始化。
A (1) ->K(1)意味着将本书的第1个关键词作为选出的第1个关键词。
1->NK (1)意味着此时该关键词的个数置为1。
m是动态选出的关键词数目，此时应该为1，因此（1)处应填1。
本题的算法是对每个关键词与已选出的关键词进行逐个比较。
凡是遇到相同的，相应的计数就增加1;如果始终没有遇到相同关键词的，则作为新选出的关键词。
流程图第2框开始对i=2，n循环，就是对书中其他关键词逐个进行处理。
流程图第3 框开始j=l，m循环，就是按已选出的关键词依次进行处理。
接着就是将关键词A(I)与选出的关键词K(j)进行比较。
因此（2)处应填K(j)。
如果A(i)=K(j)，则需要对计数器NK(j)增1，即执行NK(j)+1->NK(j)。
因此（3)处应填NK(j)+1->NK(j)。
执行后，需要跳出j循环，继续进行i循环，即根据书中的下一个关键词进行处理。
如果A(i)不等于NK(j),则需要继续与下个NK(j)进行比较，即继续执行j循环。
如果直到j循环结束仍没有找到匹配的关键词，则要将该A(i)作为新的已选出的关键词。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.下列关于对象的哪一种说法是正确的，请选出一个正确答案（）
B．对象是类的实例
2.下列哪几项是保留关键字（）
A．public
B．static
C．void
3.哪一种说法是正确的（）
C.在java语言中，return、goto、default都是关键字
4.Java中哪种整型的取值的范围恰好是-2.147483648（2-31）~ 2147483647（2-31）
C.int型
5.试图编译、运行如下类会有什么结果（）
Public class Assigment()
Public static void main()
{
Int a,b,c;
b=10;
a=b=c=10;
system.out.println(a);
}
D.代码会被正确编译，运行时将显示20
6.假定变量x=8的类型是int（它可以存放着负值），则哪些方式能正确的使X 的值翻倍，请选出4个正确的答案（）
A．x<<1;
B.x=x*2;
C.x*=2;
D.x+=X;
E.x<<=1;
7.假定有如下类（）
//Filename:Args.java
Public class Args{
Public static void main(String[] args)
{
System.out.println(arg[0]+””+args[args.length-1]);
}
}
执行如下命令后结果将使什么？
Java Args In politics stupidity is not a handicap
请选一个正确的答案
D．程序将打印In handicap
8.尝试编译、运行如下程序会得到什么结果？（）
Public class DefaultValuesTest{
Int[] ia=new int[1];
Boolean b;
Int I;
Object o;
Public static void main(String[] args){
DefaultValuesTest instance = new DefaultValuesTest();
Instance.print();
}
Public void print(){
System.out.println(ia[0]+””+””+i+””+o);
}
}
A.该程序会打印出0 false 0 null；
9.哪一个命题为真（）
A.所有类都必须定义一个构造方法
10.如下哪种类定义式不可扩展类的有效定义（）
E.final class Link{}
11.在下列选择一项正确的说法（）
A.transsient字段在序列化期间不会被保存
12.编译、运行如下程序后，将以什么次序打印出哪些数字？（）
Public class Myclass{
Public ststic void main(){
RuntimeException re=null;
throw re;
}
}
D.程序可以被无错的编译，并且运行时会抛出
ng.NullPointerException
13.断言语句抛出的异常隶属于哪个类（）
B．AssertionException
14.给定类A、B、C，其中B扩展了A，C又扩展了B，而且他们都实现了实例方法void doIt（）。
如何从C中的实例法来调用A中的doIt（）方法（）
D.这是不可能的
15．给定如下代码，哪个声明能插入至所示的位置而不会导致编译错误（）Interface MyConstance{
Int r=42;
Int s=69;
Int Area;
//插入代码
}
A.final double circumference=2*Math.PI*r;
B.int ArRa=r*s;
16.哪种说法阐明了垃圾收集和终结化机制所承诺的行为（）
C.适用于收集的对象最终由垃圾收集器销毁
17.以下哪个方法是正确的启动新县城的方法（）
C.创建新线程对象并调用方法start（）
18.哪个方法不是在String类中定义的（）
C．hashCode（）
19.下列哪个集合实现是线程安全的（）
C．vector
二．简答题
1.struts框架会使用不太的共享资源去来存储对象，共享资源区都有一个lifetime和visibilty规则，请列举出四种不同的作用域并说明作用范围，并简述转发与重定向的主要差异：
转发主要是服务器端的跳转，从一个action转发到另一个action或jsp，客户端无法感知到转发。
重定向是在服务器收到请求后，将请求重新发送到另一个地址，由客户端重新发送请求，是客户端的跳转
2.JSP标准提供了三种独立的想JSP添加代码的技术，请列举两种
<% include file=”a.html”%> <jsp:include>
前者主要用于包含静态文件，作用在jsp翻译成servlet时，将被包含的文件直接拼接到servlet中；后者包含动态文件，并且能够传递参数，作用在servlet 响应请求的过程中
4.在你以前所做的项目中，请列举一种实施效果比较好的框架技术，并结合你
的项目说明采用这种框架技术的利于弊。
谈谈你的体会，请主要结合业务与实际运行效果，针对这种框架技术的特点展开来说明。
在之前的项目中，使用了springMVC框架，该框架使用起来很方便，尤其是灵活注释配置，能够将url直接映射到方法级别，没有冗余的配置，是的前后端的开
发更高效。
但是，过于零散的配置是的统一管理前后映射、控制访问变得更加复杂，命名规范会使得方法映射互相冲突。
三．编程题
1.在wen.xml的配置文件中，利用struts的error-page元素，增加一段代码配置，将404（服务器内部错误）产生时转到error404.jsp进行处理。
或者用文字来描述出这种配置方式，系统的处理机制和原理过程
2.现由一个数组int data_arr[]={12,31,56,23,27,1,43,65,4,99},已完成如下代码，请咋爱注释处增加一段代码，实现这样的功能：将data——arr数组的内容先写入一个名为“temp.dat”文件中，再重新将该文件的内容读出，能逆序将文件的内容输出至控制台
Import java.io.IOException;
Public classs arrayTest{
Public arrayTest(){
}
Public static void main(String args[]){
//请在辈出插入完整的实现代码
}
}
3.请你为某地的营业系统写一个用户登录页面。