编程题
?编程题:
0.冒泡排序
public class Test32 {
public static void main(String[] args) {
int[] a = { 13, 43, 23, 56, 32, 6, 64 };
buble(a);
for (int i : a) {
System.out.println(i);
}
}
public static void buble(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
for (int j = a.length - 1; j > i; j--) {
if (a[j] > a[j - 1]) {
int tem = a[j];
a[j] = a[j - 1];
a[j - 1] = tem;
}
}
}
}
}
0.1给定y年m月，计算其天数
import java.util.Scanner;
public class Test29 {
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
System.out.println("请输入年份：");
int y = sca.nextInt();
System.out.println("请输入月份：");
int m = sca.nextInt();
switch (m) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(y + "年" + m + "月有31天");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(y + "年" + m + "月有30天");
break;
case 2:
System.out.println(y + "年" + m + "月有"
+ ((y % 4 == 0 && y % 100 != 0 || y % 400 == 0) ? 29 : 28)
+ "天");
break;
default:
System.out.println("不要闹，一年只有12个月！");
}
}
}
0.2单例模式
public class Singleton {
private Singleton() {
}
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
**************************************************************
public class Test40 {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.print(s1 == s2);
}
}
0.3
1.求一个输入的阶乘(递归).
/**
* 用递归求阶乘
*/
package test;
public class DG {
public static int d(int m){
int s=1;
if(m<=1)
return s;
else
return m*d(m-1);
}
public static void main(String args[]){
int n=5;
int s=d(n);
System.out.println(s);
}
}
2.现在有四个字母：“a”，“b”，“c”，“d”。编程序实现输出所有的可能组合(递归)
/**
* 全排列
*/
package test;
public class ZuHe {
//static int a[]={1,2,3,4};
static char a[]={'a','b','c','d'};
//static int c=0;
public static void main(String args[]){
zh(1);
//System.out.println(c);
}
public static void zh(int m){
if(m>=4){
for(int j=0;j<4;j++)
System.out.print(a[j]);
System.out.println();
//c++;
}else{
for(int j=m-1;j<4;j++)
{
swap(m-1,j);
zh(m+1);
swap(m-1,j);
}
}
}
public static void swap(int m,int n)
{
char temp=a[n];
a[n]=a[m];
a[m]=temp;
}
}
3.写递归算法：
录入三列数据：
例如
代码 计算公式 缺省数值
A B+C
B D/E
C 10
D F+C
E 5
F 3
要求：
提供录入界面 录入
上面几列数据（计算公式和缺省值可变），写递归算法，计算出A的结果显示
***** 4.实现一个栈
/**
* 栈的实现
* 栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。
(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。
(2)当表中没有元素时称为空栈。
(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。
栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除
*/
package cs;
import java.util.*;
public class Zhan {
private LinkedList ll=new LinkedList();
public void push(Object o){
ll.addFirst(o);
}
public Object pop(){
return ll.removeFirst();
}
public Object peek(){
return ll.getFirst();
}
public boolean empty(){
return ll.isEmpty();
}
public static void main(String[] args){
Zhan ms=new Zhan();
ms.push("zhangsan");
ms.push("lisi");
ms.push("wangwu");
System.out.println(ms.pop());
System.out.println(ms.peek());
System.out.println(ms.pop());
System.out.println(ms.empty());
}
}
***** 5.实现一个队列
/**
* 队列的操作
* 队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表
（1）允许删除的一端称为队头（Front）。
（2）允许插入的一端称为队尾（Rear）。
（3）当队列中没有元素时称为空队列。
（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。
*/
package cs;
import java.util.*;
public class DuiLie {
private LinkedList ll=new LinkedList();
public void put(Object o){
ll.addLast(o);//往队列尾插入数据
}
// 使用removeFirst()方法，返回队列中第一个数据，然后将它从队列中删除
public Object get(){
return ll.removeFirst();
}
public boolean empty(){
return ll.isEmpty();
}
public static void main(String[] args){
DuiLie mq=new DuiLie();
mq.put("zhangsan");
mq.put("lisi");
mq.put("wangwu");
System.out.println(mq.get());
System.out.println(mq.get());
System.out.println(mq.get());
System.out.println(mq.empty());
}
}
6.用2个栈实现一个队列
7.35选7
/**
* 35?7
*/
package cs;
public class SuiJiShu {
public static void main(String args[]){
int i,j;
int a[]=new int[7];
for (i=0;i<7 ;i++ )
{
int b=i;
a[i]=(int)(Math.random()*35+1);
for (j=0;j{
if(a[i]==a[j])
{
i--;
break;
}
}
//if(b==j)
//System.out.print(a[i]+" ");
}
for(i=0;i<7;i++)
System.out.println(a[i]);
}
}
8.数列排序(起泡法)
import java.util.*;
import java.io.*;
public class StringSort {
public static void main(String[]
args){
String str = null; //存放输入的字符串
String[] s = null; //存放字符串数组
int i=0;
System.out.println("请输入字符串：");
/*获得输入的字符串*/
try
{
BufferedReader buf= new BufferedReader(new InputStreamReader(System.in));
str=buf.readLine();
}
catch (IOException e)
{
e.getStackTrace();
}
/**
* 当输入的字符串不为空时，
* 用逗号对字符串进行分割。
* 再把每个子字符串放到数组s中，
* 最后对数组排序并输出。
*/
if(str!=null){
try{
StringTokenizer st = new StringTokenizer(str,",");
int num = st.countTokens();
s =new String[num];
while (st.hasMoreTokens()) {
s[i] = st.nextToken();
i++;
}
Arrays.sort(s);
System.out.println("排序后结果：");
for(int j = 0;j
}
} catch(NullPointerException e) {e.getStackTrace();}
catch(NoSuchElementException e) {e.getStackTrace();}
}
}
}
***** 9.用JAVA实现字符串排序，要求从键盘输入多个字符串，以"，"分隔，打印排序后的结果，并画出主要业务逻辑（排序过程）的流程图。
注：请使用public StringTokenizer(String str, String delim)
包含方法：public boolean hasMoreTokens()、public String nextToken()
package javaproject;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
public class WordString {
/**
* 1) 首先，如果当前数组元素中含有"word"子串，那么停止当前操作，检查下一个数组元素。
* 2）其次，如果数组元素中含有"bcd"子串，那么打印出该数组元素，并进入到下一个数组元素的操作。
* 3）如果当前数组元素中含有字符"end"则结束本程序，否则进入下一个数组元素的操作。
*/
public static void main(String[] args) {
/*获得输入的字符串*/
String str=null;
String subStr;
String[] wordStr=null;
int l=0;
System.out.println("请输入字符串：");
try
{
BufferedReader buf= new BufferedReader(new InputStreamReader(System.in));
str = buf.readLine();
}
catch (IOException e)
{
e.getStackTrace();
}
if(str!=null){
try{
StringTokenizer st = new StringTokenizer(str,",");
int num = st.countTokens();
wordStr =new String[num];
while (st.hasMoreTokens()) {
wordStr [l] = st.nextToken();
l++;
}
for(int i=0; i
if("word".equals(subStr)){
break;
}
}
for(int k=0; k
if("bcd".equals(subStr)){
System.out.println("含有abc的字符串是："+wordStr[i]);
break;
}
if("end".equals(subStr)){
System.out.println("程序退出：bye!"); //程序退出时打印 "bye!"
break;
}
}
}
}
catch(NullPointerException e) {e.getStackTrace();}
catch(NoSuchElementException e) {e.getStackTrace();}
catch(IndexOutOfBoundsException e){e.getStackTrace();}
}
}
}
***** 10.在有序数组中使用二分法查找数组下标(递归)
public class ChaZhao {
/**
* @param args
* 使用二分查找数组下标
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[]={1,2,3,4,5,6,7};
System.out.println(new ChaZhao().ef(a, 0, 6, 8));
}
public int ef(int a[],int l,int r,int n){
int s=-1;
int middle=(l+r)/2;
while(l<=r){
if(n==a[middle])
return middle;
else if(n>a[middle])
return ef(a,middle+1,r,n);
else
return ef(a,l,middle-1,n);
}
return s;
}
}
11.使用数学运算对整数字符串进行逆序
12.编写一个实现方法重载的程序。定义两个同名的重载方法，一个方法只接受整数参数ａ， 整数参数ｂ；另一个方法接受小数参 数ａ，整数参数ｂ，并且都返回ａ的ｂ次幂。
***** 13.动物特性描述：
狗生活在陆地上（是一种陆生），既是动物。狗通常情况下和人大招呼会通过“摇尾巴”，在被抚摸感到舒服的时候，会“汪汪汪叫”，受到惊吓，会发出“呜呜”声。
猫生活在陆地上（是一种陆生），既是动物。猫通常情况下和人大招呼会发出“喵喵”声，在被抚摸感到舒服的时候，会 发出“咕噜”声，受到惊吓，会发出“嘶嘶”声。
青蛙是两栖动物（既是一种陆生又是水生），既是动物。有鳃、卵生，情绪好的时候，会发出“呱呱”声，受到惊吓，会发出“扑通”一声跳下水
package jk;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Dog d=new Dog();
Cat c=new Cat();
QingWa qw=new QingWa();
d.daZhaoHu();
d.shengHuo();
d.shuFu();
d.jingXia();
c.daZhaoHu();
c.shengHuo();
c.shuFu();
c.jingXia();
qw.shengHuo();
qw.shuFu();
qw.jingXia();
}
}
interface Animal {
void shuFu();
void jingXia();
}
abstract class Animal1 {
abstract void daZhaoHu();
public void shengHuo(){
System.out.println("生活在陆地上")
;
}
}
public class QingWa implements Animal{
public void shengHuo(){
System.out.println("青蛙是两栖动物");
}
public void shuFu(){
System.out.println("青蛙呱呱");
}
public void jingXia(){
System.out.println("青蛙扑通");
}
}
public class Dog extends Animal1 implements Animal{
public void daZhaoHu(){
System.out.println("狗摇尾巴");
}
public void shuFu(){
System.out.println("狗汪汪汪叫");
}
public void jingXia(){
System.out.println("狗呜呜");
}
}
public class Cat extends Animal1 implements Animal {
public void daZhaoHu(){
System.out.println("猫喵喵");
}
public void shuFu(){
System.out.println("猫咕噜");
}
public void jingXia(){
System.out.println("猫嘶嘶");
}
}
*****14.求两个给定时间的天数差（可以不考虑2月份特殊情况）并用main函数进行测试。
package cs;
import java.util.Date;
public class RiQi {
/**
* @param args
*
* 输出两个日期的天数差
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Date d=new Date();
d.setDate(1);
Date d1=new Date();
d1.setDate(10);
System.out.println((d1.getTime()-d.getTime())/(1000*60*60*24));
}
}
15.某一密码仅使用K、L、M、N、O共5个字母，密码中的单词从左向右排列，密码单词必须遵循如下规则：
（1）密码单词的最小长度是两个字母，可以相同，也可以不同
（2）K不可能是单词的第一个字母
（3）如果L出现，则出现次数不止一次
（4）M不能是最后一个也不能是倒数第二个字母
（5）K出现，则N就一定出现
（6）O如果是最后一个字母，则L一定出现
编写程序实现如下功能：
（1）输出全部符合该要求的2个字符的密码单词；
（2）从键盘获得单词，判断该单词是否符合密码单词规则
*****16.多线程:4窗口同时买票.
public class MaiPiao {
/**
* @param args
* 多线程
* 四个窗口同时卖票
* 创建多线程有两种方法：继承Thread类和实现Runnable接口。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ThreadTest t=new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
class ThreadTest implements Runnable{
private int tickets=100;
public void run(){
while(tickets>0){
System.out.println(Thread.currentThread().getName()+"is saling ticket "+tickets--);
}
}
}
*****17.设计模式:Singleton(单例模式)编程.
public class Singleton {
/*一个类只需要提供一个实例时使用单例模式，如计数器*/
public static void main(String[] args){
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
for (int i=0; i<20; i++) {
System.out.println("s1:"+s1.nextValue());
System.out.println("s2:"+s2.nextValue());
}
}
/*第一种形式安全
//在自己内部定义自己一个private实例,只供内部调用
private static Singleton st = new Singleton();
//私有构造函数
private Singleton(){}
private long count = 0;
//返回一个Singleton类型的对象
public static Singleton getInstance(){
return st;
}*/
//这个方法比上面有所改进，不用每次都进行生成对象，
//只是第一次使用时生成实例，提高了效率！
private static Singleton st =null;
private Singleton(){}
private long count = 0;
public static Singleton getInstance(){
if(st==null)
st=new Singleton();
return st;
}
/*计数器*/
public long nextValue() {
return ++count;
}
}
18.设计模式:Factory Method(工厂方法模式)编程.
package com.javapatterns.singtelon.demos;
public class LazySingtelon
{
private static LazySingtelon m_registry=null;
private static Object m_instance;
/**
*私有的默认构造子，保证外界无法直接实例化
*/
private LazySingtelon(){}
/**
*静态工厂方法，返还此类的唯一实例
*/
synchronized public static LazySingtelon getInstance()
{
if(m_instance==null)
{
m_instance=new LazySingtelon();
}
return (LazySingtelon) m_instance;
}
}
-------------------
import java.util.HashMap;
public class RegSingtelon
{
static private HashMap m_registry=new HashMap();
static
{
RegSingtelon x=new RegSingtelon();
m_registry.put(x.getClass().getName(),x);
}
/**
*保护的默认构造子
*/
protected RegSingtelon(){}
/**
*静态工厂方法，返还此类唯一的实例
*/
static public RegSingtelon getInstance(String name)
{
if(name==null)
{
name="com.javapatterns.singtelon.demos.RegSingtelon";
}
if(m_registry.get(name)==null)
{
try
{
m_registry.put(name,
Class.forName(name).newInstance());
}
catch(Exception e)
{
System.out.println("Error happened" );
}
}
return (RegSingtelon)(m_registry.get(name));
/**
*一个事业性的商业方法
*/
}
public String about()
{
return "Hello,I am RegSingtelon!";
}
}
---------------------
import java.util.HashMap;
public class RegSingtelonChild extends RegSingtelon
{
public RegSingtelonChild(){}
/**
*静态工厂方法
*/
static public RegSingtelonChild getInstance()
{
return(RegSingtelonChild)
RegSingtelon.getInstance("com.javapatterns.singtelon.demos.RegSingtelonChild");
}
/**
*一个示意性的商业方法
*/
public String about()
{
return "Hello,I am RegSingtelonChild!";
}
}
*****19.有一字符串数组wordStr[]，对其中每个元素依次进行如下操作：
1) 首先，如果当前数组元素中含有"word"子串，
那么停止当前操作，检查下一个数组元素。
2）其次，如果数组元素中含有"bcd"子串，那么打印出该数组元素，并进入到下一个数组元素的操作。
3）如果当前数组元素中含有字符"end"则结束本程序，否则进入下一个数组元素的操作。
要求，编写程序段或算法，并画出流程图。
public class ShiJiu {
/**
* @param args
* 第十九题
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String wordStr[]=new String[10];
wordStr[0]="hhword";
wordStr[1]="bcdkjl";
wordStr[2]="jklendnjfkd";
wordStr[3]="bcdjksl";
for(int i=0;i
s.append(wordStr[i]);
if(s.indexOf("word")>=0)
continue;
else if(s.indexOf("bcd")>=0){
System.out.println(wordStr[i]);
continue;
}else if(s.indexOf("end")>=0){
break;
}
}
}
}
*****20.现有俩个字符串，（String A; String B）如果字符串A包含字符串B那么请将字符串B倒序，然后替换它在A中的原位置。
import java.util.Scanner;
public class ReplaceStr
{
public static void main(String[] args){
try{
System.out.println("请输入字符串A:");
Scanner stra = new Scanner(System.in);
String a = stra.next();
System.out.println("请输入字符串B:");
Scanner strb = new Scanner(System.in);
String b = strb.next();
ReplaceStr rs = new ReplaceStr();
String replacea = rs.sunString(a,b);
System.out.println("替换后的字符串："+replacea);
}catch(Exception e){e.getStackTrace();}
}
/**
* 如果字符串b是字符串a的字串
* 则将字符串b倒序后替换
*/
public String sunString(String a, String b){
if ((a!=null)&&(b!=null)&&(a.indexOf(b)!= -1)){
StringBuffer sb = new StringBuffer(b);
StringBuffer sb2=sb.reverse(); //将字符串b倒序
String c = new String(sb2);
for(int i=https://www.wendangku.net/doc/c112328301.html,stIndexOf(b); i>=0; i=https://www.wendangku.net/doc/c112328301.html,stIndexOf(b, i-1)){
if(i==0){
a = c+a.substring(i+1, a.length());
}
else{
a = a.substring(0, i)+c+a.substring(i+1, a.length());
}
}
}
return a;
}
}
21.字符串替换
import java.util.Scanner;
public class ReplaceStr
{
public static void main(String[] args){
try{
System.out.println("请输入字符串A:");
Scanner stra = new Scanner(System.in);
String a = stra.next();
System.out.println("请输入字符串B:");
Scanner strb = new Scanner(System.in);
String b = strb.next();
ReplaceStr rs = new ReplaceStr();
String replacea = rs.sunString(a,b);
System.out.println(
"替换后的字符串："+replacea);
}catch(Exception e){e.getStackTrace();}
}
/**
* 如果字符串b是字符串a的字串
* 则将字符串b倒序后替换
*/
public String sunString(String a, String b){
if ((a!=null)&&(b!=null)&&(a.indexOf(b)!= -1)){
StringBuffer sb = new StringBuffer(b);
StringBuffer sb2=sb.reverse(); //将字符串b倒序
String c = new String(sb2);
for(int i=https://www.wendangku.net/doc/c112328301.html,stIndexOf(b); i>=0; i=https://www.wendangku.net/doc/c112328301.html,stIndexOf(b, i-1)){
if(i==0){
a = c+a.substring(i+1, a.length());
}
else{
a = a.substring(0, i)+c+a.substring(i+1, a.length());
}
}
}
return a;
}
}