学习面试题Day07

1、打印出100以内的素数
该编程题的思路大致如下：
（1）完成一个判断某整数是否为素数的方法；
（2）循环1--100；
（3）每循环一次就判断一次，返回true则打印；
package com.example.demo1;
public class Number {
public static void main(String[] args) {
//遍历1到100
for (int i = 1; i <=100; i++) {
if(isPrime(i)){ //判断是否为素数
System.out.println(i); //打印素数
}
}
}
//判断一个整数是否是素数的方法
public static boolean isPrime(int num){
if(num==1){ //1不是素数，直接返回false
return false;
}
//从2开始到该整数的2次根之间遍历
long sqrtNum=(long)Math.sqrt(num); //得到该数的2次根
for (int i = 2; i <=sqrtNum; i++) {
if(num%i==0){ //判断能否除尽
return false; //返回false
}
}
return true; //返回true
}
}

2、打印九九乘法口诀表。
该编程题的思路大致如下：
（1）循环1-9，采用两个循环变量，一个控制行，一个控制列；
（2）每循环一次就打印一句，若控制列的循环变量到底了则打印换行。
package com.example.demo1;
public class NineNineMulitTable {
public static void main(String[] args) {
//循环，初始化i和j为1
for (int i = 1,j=1; j <=9; i++) {
//间隔打印它们的每一项
System.out.print(i+"*"+j+"="+i*j+"\t");
if(i==j){ //判断是否该换行
i=0; //将i值赋0
j++; //j自加1
System.out.println(); //换行
}
}
}
}

3、打印10000以内的回文数字。
该编程题的思路大致如下：
（1）完成一个把数字按位调换顺序的方法；
（2）循环10-9999；
（3）每循环一次就判断一次，返回true则打印；
package com.example.demo1;
public class CircleNumber {
public static void main(String[] args) {
//遍历10-10000
for (int i = 10; i < 10000; i++) {
if(isCircleNumber(i)){ //判断当前数是否为回文数
System.out.println(i+"是回文数"); //打印
}
}
}
//判断是否为回文数的方法
public static boolean isCircleNumber(int num){
int oldValue=num; //保存原值
int temp=0; //反过来的值，初始化为0
while(num>0){ //循环number的每一位数值
temp=temp*10+num%10; //得到一个数字
num/=10; //num减少一位
}
return temp==oldValue; //判断反值与原值是否相等
}
}

4、获得任一个时间的下一天的时间。
package com.example.demo1;
import java.util.Date;
public class NextDay {
public static void main(String[] args) {
Date now =new Date(); //获得当前时间
//打印下一天的时间
System.out.println(getNextDay(now));
}
//获得下一天
public static Date getNextDay(Date d){
long addTime=1; //以1为乘以的基数
addTime *=1; //1天以后，如果是30天以后，这里就是30
addTime *=24; //1天24小时
addTime *=60; //1小时60分钟
addTime *=60; //1分钟60秒
addTime *=1000; //1秒1000毫秒
//用毫秒数构造新的日期
Date date =new Date(d.getTime()+addTime);
return date; //返回结果
}
}

5、50个人围成一圈数到3和3的倍数时出圈，问剩下的人是谁？在原来的位置是多少？
该编程题的思路大致如下：
（1）首先把数据填充到数组或链表中；
（2）用一个while循环进行出圈，直到只剩下一个元素留下。
package com.example.demo1;
import java.util.LinkedList;
import java.util.List;
public class Cycle {
public static int cycle(int total, int k) { // 功能方法
List<Integer> datalist = new LinkedList<Integer>(); // 创建链表对象
for (int i = 0; i < total; i++) { // 添加数据元素
datalist.add(new Integer(i + 1));
}
// 定义下标，模拟已经去掉一个元素，因此从-1开始
int index = -1;
// 一直循环去除数据，直到只剩下一个元素
while (datalist.size() > 1) {
index = (index + k) % datalist.size(); // 得到应该出局的下标
datalist.remove(index--); // 去除元素
}
return ((Integer) datalist.get(0).intValue()); // 返回它的值
}
public static void main(String[] args) {
System.out.println("该数字原来的位置是："+cycle(50, 3));
}
}

6、将某个时间以固定格式转化成字符串。
package com.example.demo1;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormat {
public static void main(String[] args) {
Date now =new Date(); //得到现在时间
System.out.println(dateFormatStr(now)); //打印现在时间的字符串格式
}
//得到固定字符串格式的方法
public static String dateFormatStr(Date date){
//定义字符换格式
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str=sdf.format(date); //进行格式化，并得到字符串
return str; //返回结果
}
}

7、用java实现一个冒泡排序算法。
package com.example.demo1;

public class MaoPaoSort {
public static void main(String[] args) {
int [] arr={3,5,7,1,8,11,9}; //定义数组
maopaoSort(arr); //开始排序
}
//排序方法
public static void maopaoSort(int [] arrys){
//定义临时变量temp
int temp=0;
//用i我下标，遍历数组
for (int i = 0; i < arrys.length; i++) {
//对于每一个数组元素，从0到还未排序的最大下标，总是把最大的数放在后面
for (int j = 0; j < arrys.length-i-1; j++) {
if(arrys[j]>arrys[j+1]){ //判断当前数字与后面数字的大小
temp=arrys[j];
arrys[j]=arrys[j+1];
arrys[j+1]=temp;
}
}
}
maopaoPrint(arrys); //打印
}
//打印方法
public static void maopaoPrint(int [] arrys){
for (int i = 0; i < arrys.length; i++) { //遍历
System.out.print(arrys[i]+" "); //打印，以空格隔开
}
System.out.println(); //换行
}
}

8、用java实现一个插入排序算法。
package com.example.demo1;
public class InsertSort {
public static void main(String[] args) {
int [] arr={3,5,4,1,8,11,9}; //定义数组
doInsertSort(arr); //开始是排序
}
//排序方法
public static void doInsertSort(int [] arrys){
int len=arrys.length; //获取数组的长度
for (int i = 0; i < len; i++) { //遍历数组，从1开始
int j; //定义变量j
int temp=arrys[i]; //临时存储当前的数字
for (j=i ;j>0; j--) { //遍历i之前的数字
//如果前面的数字大于后面的，则把大的值赋值给后面的
if(arrys[j-1]>temp){
arrys[j]=arrys[j-1];
}else
//如果当前的数，小于前面的数，那就说明不小于前面所有的数，
//因为前面已经是排好了序的，所以直接退出当前一轮的比较
break;
}
arrys[j]=temp; //把空缺位置的数字赋值为原有的值
}
print(arrys); //打印
}
//打印方法
public static void print(int [] arr){
for (int i = 0; i < arr.length; i++) { //遍历
System.out.print(arr[i]+" "); //打印，以空格隔开
}
System.out.println(); //换行
}
}

9、用java实现一个快速排序算法。
package com.example.demo1;
public class QuickSort {
public static void main(String[] args) {
int [] arr=new int[]{5,9,8,4,7,3,6,2};
print(arr);
sort(arr, 0, arr.length-1);
print(arr);
}
//打印方法
public static void print(int [] arr){
for (int i = 0; i < arr.length; i++) { //遍历
System.out.print(arr[i]+" "); //打印，以空格隔开
}
System.out.println(); //换行
}
public static void sort(int [] arr,int low,int high){
if(low>=high){ //low小于或等于high，直接返回
return;
}
if((high-low)==1){ //如果只有两个数，则直接比较
if(arr[0]>arr[1]){
swap(arr,0,1);
}
return;
}
int povit=arr[low]; //取第一个数作为中间数
//左滑块当前的下标数，从第二个数字开始，从最后一个数字开始
int left=low+1;
int right=high; //右滑块当前的下标数
while(left<right){ //左右循环
//从左边开始找
while(left<right && left<=high){ //如果左小于右则一直循环
if(arr[left]>povit){ //找到一个大的数字没有
break;
}
left++; //左下标往右移动
}
//从右边开始找
while(left<=right && right>low){ //如果做大于右则一直循环
if(arr[right]<=povit){ //找到一个小的数字没有
break;
}
right--; //右下标往左移动
}
if(left<right){ //如果还没找完，则交换数字
swap(arr, right, left);
}
}
swap(arr,low,right); //交换中间数字
sort(arr,low,right); //排序前面数组
sort(arr,right+1,high); //排序后面数组
}
//调位方法
public static void swap(int [] arr,int i,int j){
int temp;
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}

10、怎样实现Singleton(单例)模式编程？
package com.example.demo1;
public class SingleObjectPattern {
public static void main(String[] args) {
ConnectionPoolA cp1=ConnectionPoolA.getConnectionPool();
ConnectionPoolB cp2=ConnectionPoolB.getConnectinPool();
ConnectionPoolA cp3=ConnectionPoolA.getConnectionPool();
ConnectionPoolB cp4=ConnectionPoolB.getConnectinPool();
System.out.println(cp1==cp3);
System.out.println(cp2==cp4);
}
}
package com.example.demo1;
/*
* 饿汉式单例，优点：实现简单；缺点：在不需要的时候，白创造了对象，造成了资源浪费
*/
public class ConnectionPoolA {
private static ConnectionPoolA cp=new ConnectionPoolA();//创建实例
private ConnectionPoolA(){} //私有化构造方法
public static ConnectionPoolA getConnectionPool(){
return cp;
}
}
package com.example.demo1;
/*
* 懒汉式单例，优点：需要对象时才创建对象；缺点：线程不安全；
*/
public class ConnectionPoolB {
private static ConnectionPoolB cp;
private ConnectionPoolB(){} //私有化构造方法
//以此类的锁来保证多线程的安全
public static synchronized ConnectionPoolB getConnectinPool(){
if(cp==null){
cp=new ConnectionPoolB(); //创建实例
}
return cp;
}
}