Java基础题&答案

1.完成数组 int[] a = {
   100,40, 60, 87, 34, 11,
56, 0}的快速排序、冒泡排序；
快速排序
实现代码：
public class Test001 {
   
public static void main(String[] args) {
   
int[] a = new int[]{
   100,40, 60, 87, 34, 11, 56, 0};
System.out.println("未排序之前的数据是：");
print(a);
System.out.println("排序之后的数据是：");
sort(a,0,a.length-1);
print(a);
}
//打印方法
public static void print(int[] b){
   
for(int i=0; i<b.length;
i++){
   System.out.print(b[i]+
" ");
}
System.out.println();
}
//排序方法
static void sort(int[] a,int low,int
high){
    if(low >= high) return;//low小于high，
则直接返回if((high - low)==1){
   //如果只有两个数字，
则直接比较
if(a[0] > a[1])
swap(a,0,1);
return;
}
int pivot = a[low];//取第一个数作为中间数
int right = high;
while(left<right){
   
//从左边开始找
while(left < right && left <= high){
   //如果左小于右则一直循环
if(a[left] > pivot) break;
left++;//左下标往右边走一点
}
//从右边开始找
while(left <= right && right > low){
   //如果左大于右则一直循环
if(a[right] <= pivot)
break;
right--;//右下标往左走一点
}
if(left < right)//如果还没有找完，则交换数字
swap(a,right,left);
}
swap(a,low,right);
sort(a,low,right);
sort(a,right+1,high);
}
//调位方法
private static void swap(int[] array, int i, int j){
   
int temp;
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
打印结果为：
未排序之前的数据是：
100 40 60 87 34 11 56 0
排序之后的数据是：
0 11 34 40 56 60 87 100
冒泡排序
实现代码：
public class Test002 {
   
public static void main(String[] args) {
   
int[] arr = {
   100,40, 60, 87, 34, 11, 56, 0};//定义数组
System.out.println("未排序之前的数据是：");
maopaoPrint(arr);
System.out.println();
System.out.println("排序之后的数据是：");
maopaoSort(arr);
}
//排序方法
public static void maopaoSort(int[] arrys){
   
//定义临时变量temp
int temp = 0;
//用j表示下标，遍历数组
for(int j=0; j<arrys.length; j++){
   
//对于每一个数组元素，从0到还未排序的最大下标，总是把最大的数字放在后
边
for(int k=0; k<arrys.length-j-1; k++){
   
if(arrys[k]>arrys[k+1]){
   //判断当前数字与后面数字的大小
temp = arrys[k];
arrys[k] = arrys[k+1];
arrys[k+1] = temp;
}
}
}
maopaoPrint(arrys);//打印输出
}
//打印方法
public static void maopaoPrint(int[] l){
   
for(int i=0; i<l.length;
i++){
    System.out.print(l[i]+" ");//从小到
大的输出
}
}
} 打印结果为：
未排序之前的数据是：
100 40 60 87 34 11 56 0
排序之后的数据是：
0 11 34 40 56 60 87 100
2.采用折半查找的算法，在数组中查询到某
个数；
实现代码：
import java.util.Scanner;
public class Test003 {
   
public static int Max = 20;
// 数据数组源
public static int data[] = {
    12, 16, 19, 22, 25, 32, 39,39, 48, 55,
57, 58,
63, 68, 69, 70, 78, 84, 88, 90, 97 };
// 计数器
public static int count = 1;
public static void main(String[] args)
{
    System.out.println("请输入您要查找的数字：");
Scanner sc = new Scanner(System.in);
int KeyValue = sc.nextInt();
// 调用折半查找
if (Search(KeyValue)) {
   
// 输出查找次数
System.out.println("共查找了" + count + "次");
} else {
   
// 输出没有找到数据
System.out.println("抱歉,数据数组源中找不到您输入的数字");
}
}
//折半查找法
public static boolean Search(int k) {
   
int left = 0;// 左边界变量
int right = Max - 1;// 右边界变量
int middle;// 中位数变量
while (left <= right) {
   
middle = (left + right) / 2;
if (k < data[middle]) {
   
right = middle - 1;//查找前半段
} else if (k > data[middle])
{
    left = middle + 1;//查找后
半段
} else if (k == data[middle])
{
    System.out.println("Data[" + middle + "] = " +
data[middle]);
}
return true;
count++;
}
return false;
}
}
3.输入一个字符串，其中包含数字、特殊符
号(像:￥、&、（、>等)、大小写字母等，然
后输出每个字符串或符号的 ASCII 码的和；
例如：输入“@#$%^&*():"|”
，则打印出643。
实现代码：
public class Test001 {
   
public static void main(String[] args)
{
    System.out.println("请输入一个字符串：");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
int sum = 0;
for(int i=0; i<str.length();
i++){
   sum = sum+str.charAt(i);
}
System.out.println("您输入的字符串每个字节相加的和为："+sum);
}
}
4. 将一个数组中值=0 的项去掉,将不为 0 的
值存入一个新的数组
比如:
int a[]={
   0,1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
生成的新数组为:
int b[]={
   1,3,4,5,6,6,5,4,7,6,7,5}
实现代码：
import java.util.*;
public class Test001 {
   
public static void main(String[] args) {
   
int a[]={
   0,1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
List<Integer> list = new ArrayList<Integer>();
for(int i =0;i<a.length;i++){
   
if(a[i]!=0){
   
list.add(a[i]);
}
}
int b[] = new int[list.size()];
for(int i = 0;i<list.size();i++){
   
b[i] = list.get(i);
}
System.out.println("原数组为：");
for(int i
=0;i<a.length;i++){
    System.
out.print(a[i]+" ");
}
System.out.println();
System.out.println("去掉值为0的项之后为：");
for(int i:b){
   
System.out.print(i+" ");
}
}
}
5. 定义 10 个长度的 Student 数组，将 10 个
Student 对象的年龄全部加 1，然后把 10 个
Student 对象的详细信息逐行打印出来(数组
和 ArrayList 实现)
实现代码：
第一个类：
public class Student
{
   public String
name;public String
sex; public int
age;
public String getName() {
   
return name;
}
public void setName(String name) {
   
this.name = name;
}
public String getSex() {
   
return sex;
}
public void setSex(String sex) {
   
this.sex = sex;
}
public int getAge() {
   
return age;
}
public void setAge(int age) {
   
this.age = age;
}
public Student(String name, String sex, int age) {
   
super();
this.name = name;
this.sex = sex;
this.age = age;
}
}
第二个类：
import java.util.ArrayList;
import java.util.List;
public class Test001 {
   
static Student[] s = new Student[10];
int k = 1;
public static void main(String[] args)
{
    List<Student> li = new
ArrayList<Student>();for(int i=0; i<10;
i++){
   
li.add(new Student("zhangsan"+i,"男",20));
}
for(int i=0; i<10;
i++){
   (li.get(i).age)
++;
}
for(int i=0; i<10;
i++){
    System.out.println(li.get(i).getName(
)+"
"+li.get(i).getSex()+" "+li.get(i).getAge());
}
6. 有工人,农民,教师,科学家,服务生,其中,
工人,农民,服务生只有基本工资.教师除基本
工资外,还有课酬(元/天),科学家除基本工资
外,还有年终奖,请你写出相关类,将各种类型
的员工的全年工资打印出来
实现代码：（共有 7 个类）
第一个类：
package com.softeem.zy006;
/**
* 定义一个人的接口，以供实现
*/
public interface People{
   
public double num();
}
第二个类：
package com.softeem.zy006;
/**
* 工人类
*/
public class Worker implements People{
   
private double montherSalary;
public Worker(double montherSalary) {
   
super();
this.montherSalary = montherSalary;
}
public double num() {
   
return getMontherSalary()*12;
}
public double getMontherSalary() {
   
return montherSalary;
}
public void setMontherSalary(double montherSalary) {
   
this.montherSalary = montherSalary;
}
}
第三个类：
package com.softeem.zy006;
/**
* 农民类
*/
public class Peasant implements People{
   
private double montherSalary;
public Peasant(double montherSalary) {
   
super();
this.montherSalary = montherSalary;
}
public double getMontherSalary() {
   
return montherSalary;
}
public void setMontherSalary(double montherSalary) {
   
this.montherSalary = montherSalary;
}
public double num() {
   
return getMontherSalary()*12;
}
}
第四个类：
package com.softeem.zy006;
/**
* 教师类
*/
public class Teacher implements
People{
   private double montherSalary;
private double daySalary;
public Teacher(double montherSalary, double daySalary) {
   
super();
this.montherSalary = montherSalary;
this.daySalary = daySalary;
}
public double num() {
   
return getMontherSalary()*12+getDaySalary()*365;
}
public double getMontherSalary() {
   
return montherSalary;
}
public void setMontherSalary(double montherSalary) {
   
this.montherSalary = montherSalary;
}
public double getDaySalary() {
   
return daySalary;
}
public void setDaySalary(double daySalary) {
   
this.daySalary = daySalary;
}
}
第五个类：
package com.softeem.zy006;
/**
* 科学家类
*/
public class Scientist implements People{
   
private double montherSalary;
private double projectSalary;
public Scientist(double montherSalary, double projectSalary) {
   
super();
this.montherSalary = montherSalary;
this.projectSalary = projectSalary;
}
public double num(){
   
return getMontherSalary()*12+getProjectSalary();
}
public double getMontherSalary() {
   
return montherSalary;
}
public void setMontherSalary(double montherSalary) {
   
this.montherSalary = montherSalary;
}
public double getProjectSalary() {
   
return projectSalary;
}
public void setProjectSalary(double projectSalary) {
   
this.projectSalary = projectSalary;
}
}
第六个类：
package com.softeem.zy006;
/**
* 服务员类
*/
public class Waiter implements People{
   
private double montherSalary;
public Waiter(double montherSalary) {
   
super();
this.montherSalary = montherSalary;
}
public double num() {
   
return getMontherSalary()*12;
}
public double getMontherSalary() {
   
return montherSalary;
}
public void setMontherSalary(double montherSalary) {
   
this.montherSalary = montherSalary;
}
}
第七个类：
package com.softeem.zy006;
/**
* 测试类
*/
public class Test {
   
public static void main(String[] args)
{
   Test a = new Test();
Worker w = new Worker(1000);
System.out.println("工人的年薪为：" + w.num()+"元");
Peasant p = new Peasant(2500);
System.out.println("农民的年薪为："+p.num()+"元");
Teacher t = new Teacher(4500,50);
System.out.println("教师的年薪为："+t.num()+"元");
Scientist e = new Scientist(10500,30000);
System.out.println("科学家的年薪为：" + e.num()+"元");
Waiter y = new Waiter(3400);
System.out.println("服务生的年薪为：" + y.num());
}
}
打印结果为：
工人的年薪为：12000.0元
农民的年薪为：30000.0元
教师的年薪为：72250.0元
科学家的年薪为：156000.0元
服务生的年薪为：40800.0
7. 创建一个复数类 complex，对复数进行数
学运算，复数具有如下格式：
RealPart+ImaginaryPart*I
其中，I 为－１的平方根。
要求如下：
（１）利用浮点变量表示此类的私有数据。提供两个构造方法，一个用于此类声明时对
象的初始化；一个为带默认值得无参构造方法。
（２）提供两复数加、减、乘的运算方法。
（３）按格式（a,b）打印复数。其中 a 为实部，b 为虚部。
实现代码：
package com.softeem.zy007;
/**
* 创建一个复数类complex，对复数进行数学运算，复数具有如下格式：
RealPart+ImaginaryPart*I 其中，I为－１的平方根。
* 要求如下： （１）利用浮点变量表示此类的私有数据。提供两个构造方法，一个用于此类
声明时对象的初始化；一个为带默认值得无参构造方法。
* （２）提供两复数加、减、乘的运算方法。 （３）按格式（a,b）打印复数。其中a为实部，
b为虚部。
*/
public class ComplexNumber implements Cloneable {
   
/** 复数的实部 */
private double realPart;
/** 复数的虚部 */
private double imaginaryPart;
/** 默认构造函数 */
public ComplexNumber() {
   
this.realPart = 0.0;
this.imaginaryPart = 0.0;
}
/**
* 构造函数
*
* @param a
*
* @param b
*
*/
实部
虚部
public ComplexNumber(double a, double b) {
   
this.realPart = a;
this.imaginaryPart = b;
}
/**
* 复数的加法运算。 c = a + b的运算法则是： c.实部 = a.实部 + b.实部; c.虚
部 = a.虚部 + b.虚部
*
* @param aComNum
* 加数
* @return
*/
public ComplexNumber add(ComplexNumber aComNum) {
   
if (aComNum == null)
{
    System.err.println("对象不能够为null！");
return new ComplexNumber();
}
return new ComplexNumber(this.realPart + aComNum.getRealPart(),
this.imaginaryPart + aComNum.getImaginaryPart());
}
/**
* 复数的减法运算。 c = a - b的运算法则是： c.实部 = a.实部 - b.实部; c.虚
部 = a.虚部 - b.虚部
*
* @param aComNum
* 减数
* @return
*/
public ComplexNumber decrease(ComplexNumber aComNum) {
   
if (aComNum == null)
{
    System.err.println("对象不能够为null！");
return new ComplexNumber();
}
return new ComplexNumber(this.realPart - aComNum.getRealPart(),
this.imaginaryPart - aComNum.getImaginaryPart());
}
/**
* 复数的乘法运算。 c = a * b的运算法则是： c.实部 = a.实部 * b.实部 - a. 虚部 * b.虚部; c.虚部 = a.虚部 *
* b.实部 + a.实部 * b.虚部;
*
* @param aComNum
* 乘数
* @return
*/
public ComplexNumber multiply(ComplexNumber aComNum) {
   
if (aComNum == null)
{
    System.err.println("对象不能够为null！");
return new ComplexNumber();
}
double newReal = this.realPart * aComNum.realPart -
this.imaginaryPart
* aComNum.imaginaryPart;
double newImaginary = this.realPart * aComNum.imaginaryPart
+ this.imaginaryPart * aComNum.realPart;
ComplexNumber result = new ComplexNumber(newReal, newImaginary);
return result;
}
/**
* 复数的除法运算。 c = a / b 的运算法则是： c.实部 = (a.实部 * b.实部 + a. 虚部 * b.虚部) / (b.实部
* *b.实部 + b.虚部 * b.虚部); c.虚部 = (a.虚部 * b.实部 - a.实部 * b.虚
部) / (b.实部 * b.实部 +
* b.虚部 * b.虚部);
*
* @param aComNum
* 除数
* @return
*/
public ComplexNumber divide(ComplexNumber aComNum) {
   
if (aComNum == null)
{
    System.err.println("对象不能够为null！");
return new ComplexNumber();
}
if ((aComNum.getRealPart() == 0) && (aComNum.getImaginaryPart()
== 0)) {
   
System.err.println("除数不能够为0！");
return new ComplexNumber();
}
double temp = aComNum.getRealPart() * aComNum.getRealPart()
+ aComNum.getImaginaryPart() *
aComNum.getImaginaryPart();
double crealpart = (this.realPart * aComNum.getRealPart() +
this.imaginaryPart
* aComNum.getImaginaryPart())
/ temp;
double cimaginaryPart = (this.imaginaryPart *
aComNum.getRealPart() - this.realPart
* aComNum.getImaginaryPart())
/ temp;
return new ComplexNumber(crealpart, cimaginaryPart);
}
/**
* 将一个复数显示为字符串
*/
public String toString() {
   
return this.realPart + " + " + this.imaginaryPart + "i";
}
/**
* 比较一个对象是否和这个复数对象的值相等
*/
public boolean equals(Object obj) {
   
if (obj == null) {
   
return false;
的方法。
}
// 首先判断a是不是一个复数对象，instanceof关键字是用来判断对象的类型。
if (obj instanceof ComplexNumber) {
   
// 如果a是复数对象，需要将它强制类型转换成复数对象，才能调用复数类提供
ComplexNumber b = (ComplexNumber) obj;
if ((this.realPart == b.getRealPart())
&& (this.imaginaryPart == b.getImaginaryPart())) {
   
return true;
} else {
   
return false;
}
} else {
   
return false;
}
}
/**
* 获得该复数对象的hashcode
*/
public int hashCode() {
   
// 如果两个复数对象是equals的，那么它们的hashCode也必须相同。
// 两个值相等的复数对象通过toString()方法得到的输出字符串是一样的，
// 于是，可以把得到的字符串的hashCode当作复数对象的hashCode
return this.toString().hashCode();
}
/**
* 根据现有对象克隆一个新对象
*/
public Object clone() {
   
// 如果你要使自定义的类能够被clone,就必须实现Cloneable接口并且重写它的
clone()方法．
// 如果你仅仅重写了clone方法而没有在类的声明中添加实现Cloneable接口，调用
clone方法时将会出现
// CloneNotSupportedException异常，读者可以试试。
try {
   
ComplexNumber newObject = (ComplexNumber) super.clone();
newObject.setRealPart(this.realPart);
newObject.setImaginaryPart(this.imaginaryPart);
return newObject;
} catch (CloneNotSupportedException e) {
   
// //如果没有实现Cloneable接口，抛出异常
e.printStackTrace();
return null;
}
}
/**
* @return 返回 imaginaryPart。
*/
public double getImaginaryPart() {
   
return imaginaryPart;
}
/**
* @param imaginaryPart
* 要设置的 imaginaryPart。
*/
public void setImaginaryPart(double imaginaryPart) {
   
this.imaginaryPart = imaginaryPart;
}
/**
* @return 返回 realPart。
*/
public double getRealPart() {
   
return realPart;
}
/**
* @param realPart
* 要设置的 realPart。
*/
public void setRealPart(double realPart) {
   
this.realPart = realPart;
}
public static void main(String[] args) throws
CloneNotSupportedException {
   
ComplexNumber a = new ComplexNumber(3, 5);
ComplexNumber b = new ComplexNumber(2, 4);
System.out.println("ComplexNumber a: " + a.toString());
System.out.println("ComplexNumber b: " + b.toString());
System.out.println("(a + b) = " + a.add(b).toString());
System.out.println("(a - b) = " + a.decrease(b).toString());
System.out.println("(a * b) = " + a.multiply(b).toString());
}
System.out.println("(a / b) = " + a.divide(b).toString());
}
8. 实现圆类 circle，包含相关的成员变量和
成员方法。从圆类派生出圆柱类 cylinder。
根据建立的两个类，从键盘输入 5 个圆的半
径，5 个圆柱的半径和高度，并分别是输出
5 个圆的面积，5 个圆柱的体积
实现代码：（共有三个类）
第一个类：
package com.softeem.zy008;
public class Circle {
   
private static final float f = (float)Math.PI;
/**
* 计算出圆的面积
*/
public float getArea(float
rr){
   float area = f * rr *rr;
return area;
}
}
第二个类：
package com.softeem.zy008;
public class Cylinder extends Circle{
   
public float getVolume(float rr,float g){
   
float area = super.getArea(rr);
float volume = area*g;
return volume;
}
}
第三个类（测试类）：
package com.softeem.zy008;
import java.util.Scanner;
public class Test {
   
public static void main(String[] args)
{
   Test t = new Test();
t.Demo001();
System.out.println();
t.Demo002();
}
public void Demo001()
{
    System.out.println("计算圆的面积：");
System.out.println("请输入5个圆的半径(一行写一个半径):");
float[] f = new float[5];
for (int i = 0; i <= 4; i++) {
   
Scanner sc = new Scanner(System.in);
f[i] = sc.nextFloat();
}
for (int i = 0; i < f.length; i++)
{
   Circle c = new Circle();
float area = c.getArea(f[i]);
System.out.println("半径为" + f[i] + "的圆的面积为：" + area);
}
}
public void Demo002() {
   
System.out.println("接下来是计算圆柱的体积：");
System.out.println("请先输入5个圆柱的半径(一行写一个):");
float[] f1 = new float[5];
for (int i = 0; i <= 4; i++) {
   
Scanner sc = new Scanner(System.in);
f1[i] = sc.nextFloat();
}
System.out.println("请再分别输入5个圆柱对应的高度(一行写一个):");
float[] f2 = new float[5];
for (int i = 0; i <= 4; i++) {
   
Scanner sc = new Scanner(System.in);
f2[i] = sc.nextFloat();
}
for (int i = 0; i < 5; i++)
{
    Cylinder c = new
Cylinder();
float volume = c.getVolume(f1[i], f2[i]);
System.out.println("半径为"+f1[i]+",高为"+f2[i]+"的圆柱的体积
为："+volume);
}
}
}
9. 输入一个整数，求这个整数中每位数字相
加的和
实现代码：
package com.softeem.zy009;
import java.util.Scanner;
/**
* 输入一个整数，求这个整数中每位数字相加的和
*/
public class Test001 {
   
public static void main(String[] args)
{
   System.out.println("请输入一个整数：
");Scanner sc = new
Scanner(System.in);String s =
sc.nextLine();
int sum = 0;
for(int i=0; i<s.length(); i++){
   
sum = sum+Integer.parseInt(s.valueOf(s.charAt(i)));
}
System.out.println("您输入的整数是："+s);
System.out.println("各位数字相加的和为："+sum);
}
}
10. 编写一个 java 应用程序，要求如下
（1） 声明一个 String 类的变量并初始化值“Hello World”。
（2） 用字符串类的一个方法将上面变量的值拆分成” Hello” 和“World”两个字符
串并打印输出。
（3） 将” Hello”这个变量转换成大写、“World”转换成 小写并打印输出。
（4） 声明一个 String 类的变量并初始化值“20100110”。
（5） 将上面变量的值转换成 2010 年 1 月 10 日的形式打印输出。
实现代码：
11. 求 s=1+3+5+7+...直到 s>2000 为止
实现代码：
public class Test001 {
   
public static void main(String[] args) {
   
int sum = 0;
for(int i=1;;i=i+2){
   
public class Test001 {
   
public static final String str1 = "Hello World";
public static final String str2 = "20100110";
public static void main(String[] args) {
   
Test001 t = new Test001();
t.Demo();
}
public void Demo(){
   
String[] s = str1.split(" ");
System.out.println("拆分后为："+s[0]+"、"+s[1]);
System.out.println(s[0]+"转换成大写之后为："+s[0].toUpperCase());
System.out.println(s[1]+"转换成小写之后为："+s[1].toLowerCase());
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(str2.substring(0, 4)+"年
"+str2.substring(4,6)+"月"+str2.substring(6)+"日");
}
}
sum = sum +i;
System.out.println(sum);
if(sum>2000){
   
break;
}
}
System.out.println("程序停止：和已经大于2000了");
}
}
12. 计算 s=2!+4!+8!+11!。（首先先定义一个函
数，函数的功能就是求