学习面试题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+" ");
   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;
 }
}