Java期末考试练习题精选精讲

最新推荐文章于 2024-04-14 08:46:22 发布

考前上线的速通大师

最新推荐文章于 2024-04-14 08:46:22 发布

阅读量2.1k

点赞数 3

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_62987831/article/details/125636758

版权

java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1.定义一个名字为Main的类，在屏幕上输出以下信息：

Hello Java!

Programming is fun!

public class Main{
    public static void main(String[] args)//主代码进入{
        System.out.println("Hello Java!");//输出
        System.out.println("Programming is fun!");
    }
}

2.输入一个非负整数n，计算n！

import java.util.Scanner;
public class Main{
    public static int f(int c){//定义f（）的函数
		if(c == 0){
			return 1;
		}
		else{
			return f(c-1)*c;//递归
		}
	
		
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);//接受输入
		int i = sc.nextInt();//输入
		int a = f(i);
		System.out.println(a);//输出
		}
}

3.水仙花数是指一个N位正整数（7≥N≥3），它的每个位上的数字的N次幂之和等于它本身。例如：153=13+53+33。要求编写程序，计算所有N位水仙花数。

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();//接受输入
		

		int min = 1;
		int max = 0;

		for(int i = 0; i < N - 1; i++) {
			min *= 10;
		}
		max = min * 10 - 1;
		
		for(int i = min; i <= max; i++) {
			if(i == sum(i,N)) {
				System.out.println(i);
			}
		}		
	}
	
	//sum函数 返回一个数的各位数幂运算之和
	public static int sum(int data,int N) {
		int res = 0;//各位数幂运算之和
		
		for(int j = 0; j < N; j++) {
			int t = data % 10;//幂运算
			for(int k = 0; k < N - 1; k++) {
				t *= (data % 10);
			}
			res += t;
			data /= 10;
		}
		
		return res;
	}
}

编写一个圆环类Ring的Java程序。

a定义圆环类的2个数据成员，分别是内半径innerRadius，外半径outerRadius，这些属性通过get和set方法进行封装。

b 定义圆环类有参构造方法Ring(int innerRadius,int outerRadius),在有参构造方法中加入System.out.println("constructor");

c完成无参构造方法Ring(),要求在无参构造方法中使用this调用有参构造方法给两个半径赋值（外半径赋值3，内半径赋值1）

d 圆环类中定义 public int getArea（）方法可以返回其面积。面积求出后强制转换为整型值返回，π使用Math.PI表示。

在Main类中先生成一个圆环类对象，这个圆环的两个半径通过键盘读入，调用求面积方法求出面积后，输出面积。

然后再次定义一个圆环对象，调用无参构造方法，调用求面积方法求出面积后，输出面积。

输入格式:

输入在一行中先给出内半径，再给出外半径。

输出格式:

在一行中输出圆环的面积。

import java.awt.*;
import java.util.*;
import javax.swing.JPanel;
 
import java.io.*;
 
class Ring {//Ring 类
	public double innerRadius;
	public double outerRadius;
 
	public Ring() {
		this(1, 3);//访问调用指定的有参构造，用来区分成员变量和局部变量（重名问题）

              
	}
 
	public Ring(double innerRadius, double outerRadius) {// 两参构造
		this.innerRadius = innerRadius;
		this.outerRadius = outerRadius;
		System.out.println("constructor");
	}
 
	public double getInnerRadius() {//无参构造
		return innerRadius;
	}
 
	public void setInnerRadius(double innerRadius) {
		this.innerRadius = innerRadius;
	}
 
	public double getOuterRadius() {
		return outerRadius;
	}
 
	public void setOuterRadius(double outerRadius) {
		this.outerRadius = outerRadius;
	}
 
	public int getArea() {//getArea 方法
		return (int) (Math.PI * (this.outerRadius * this.outerRadius - this.innerRadius * this.innerRadius));
	}
 
}
 
public class Main {//主
 
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		Ring r1 = new Ring(scan.nextDouble(), scan.nextDouble());
		System.out.println(r1.getArea());
		Ring r2 = new Ring();
		System.out.println(r2.getArea());
	}
}

1. 定义一个圆柱类Cylinder
2. 里面包含私有属性 private int radius（半径）,height(高）
3. 为属性完成其setter getter方法
4. 完成带参构造方法Cylinder(int radius,height),该方法中包含一句System.out.println("Constructor with para");
5. 完成无参构造方法Cylinder()，在无参构造方法中调用有参构造方法，为半径和高赋值为2,1,该方法包含一句System.out.println("Constructor no para");
6. 完成求体积方法 public int getVolumn(){} 求圆柱体积,π使用Math.PI
定义测试类Main，在main方法中，按照顺序要求完成下列操作
从键盘接收两个数，第一个为半径，第二个为高，并利用刚才输出两个数创建圆柱体对象c1,求c1的体积并输出。
使用无参构造方法创建第二个圆柱体对象c2，求c2的体积并输出。

输入格式:

在一行中输入半径和高。

输出格式:

对每一个圆柱体输出它的体积

import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int radius = sc.nextInt();
        int height = sc.nextInt();
        Cylinder cylinder = new Cylinder(radius,height);
        System.out.println(cylinder.getVolumn());
        Cylinder cylinder1 = new Cylinder();
        System.out.println(cylinder1.getVolumn());
    }
}
class Cylinder{
    private int radius;
    private int height;
 
    public Cylinder() {
        this(2,1);
        System.out.println("Constructor no para");
    }
 
    public Cylinder(int radius, int height) {
        this.radius = radius;
        this.height = height;
        System.out.println("Constructor with para");
    }
    public int getVolumn(){
        return (int)(Math.PI*Math.pow(radius,2)*height);
    }
}

6.设计Book类，要求：1）Book类的成员属性包括：书名name（String类型）、出版日期publishDate（Date类型）、定价price（double型）；2）为Book对象提供按出版日期、价格排序的两种方式，且能够满足测试程序代码中的输入输出要求（注意代码注释中的说明）。其中，类BookComparatorByPrice的排序功能是：将一组Book对象按照价格升序排序，如果价格相同，则按照书名字母顺序排列；类BookComparatorByPubDate的排序功能是：将一组Book对象按照出版日期降序排序。裁判样例忽略

class Book{//类
    private String name;
    private Date publishDate;
    private double price;

    public Book(String name, Date publishDate, double price) {
        this.name = name;//访问属性，也可以用set
        this.publishDate = publishDate;
        this.price = price;
    }

    public String getName() {//私有类可以用
        return name;
    }

    public Date getPublishDate() {
        return publishDate;
    }

    public double getPrice() {
        return price;
    }

    public String toString(){
        return "书名:" + name + ",定价:" + price;
    }
}

class BookComparatorByPrice implements Comparator {//接口实现了排序，排序是已经定义好的接口
    public int compare(Object o1, Object o2) {//比较
        Book b1 = (Book)o1;
        Book b2 = (Book)o2;

        if( b1.getPrice() == b2.getPrice() ){
            return b1.getName().compareTo(b2.getName());
        }
        else{
           return b1.getPrice() < b2.getPrice() ? -1 :  1;
        }
    }
}

class BookComparatorByPubDate implements Comparator{
    public int compare(Object o1, Object o2) {
        Book b1 = (Book)o1;
        Book b2 = (Book)o2;

        return b2.getPublishDate().compareTo(b1.getPublishDate());
    }
}

给定英文句子，编写方法void wordPositions(String sentence)，该方法中计算sentence中的每个单词在句子中的起始位置和单词长度并输出。假设句子中只包含英文字母和空格，且单词不重复。

输入格式:

句子

输出格式:

每个单词在句子中的起始位置和单词长度

import java.util.Scanner;
import java.util.regex.*;;
public class Main {
	//子字符串modelStr在字符串str中第count次出现时的下标
	static int getFromIndex(String str, String modelStr, Integer count) {
		
	        Matcher slashMatcher = Pattern.compile(modelStr).matcher(str);
	        int index = 0;
			while(slashMatcher.find()) {//找到，准备输出
		    index++;
		    if(index == count){
		       break;
		    }
		}
	      	return slashMatcher.start();
	}
	public static void wordPositions(String sentence) {//函数
		
        String[] strings = sentence.split(" ");//分割句子
        int[] num = new int[100];、、新建数组
        for(int i = 1;i < strings.length;i++) {
        	int cnt = 0;
        	for(int j = 0;j < i;j++) {
        		if(strings[i].equals(strings[j]))几位数
        			cnt++;
        	}
        	num[i] = cnt+1;
        }
        num[0] = 1;
 
        int i = 0;
 
        while(i < strings.length) {
   System.out.println(strings[i]+": "+getFromIndex(sentence,strings[i],num[i])+", "+strings[i].length());
 
            i++;
        }
 
     }
 
	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
 
        Scanner s1 = new Scanner (System.in);
 
        String string = s1.nextLine();
 
        wordPositions(string);
 
 
	}
 
}

图书价格汇总

输入格式:

假设某图书馆中图书记录的格式为“Java程序设计： 34；Web程序设计： 56；JSP程序设计：20”（每本书的价格是整数，每本书的价格与下一本书的名字之间有一个中文；）。

输出格式:

编写一个类的方法，能够接受键盘录入的符合上述格式的图书内容字符串，输出图书记录中所有书目的总价格。

import java.util.ArrayList;
import java.util.Scanner;

public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int total=0;//新建价格
String str=sc.nextLine();//接受多个数字输入
String[] sList=str.split(";");以；为标准分割，命名为s
ArrayList<String> strList=new ArrayList<>();建立列表
for (String s:sList){strList.add(s);}截取到新建列表里
for (String s:strList){System.out.println(s);输出s
  total += Integer.parseInt(s.substring(s.indexOf("：") + 1).trim());
        }//截取查找到价格后进行类型转换，相加
System.out.println("总价格为"+total);}}

从键盘接收N个英文字符串（其中不同的字符串数量大于10），从头开始取5个不同的字符串放入一个集合S1，然后接着取5个不同的字符串放入另一个集合S2，按照字母顺序输出S1和S2的并集中的每个字符串（字符串区分大小写）

输入格式:

一行以空格分开的英文字符串（不同的字符串数量大于10）。

输出格式:

按照字母顺序（先比较字符串首字母，首字母相同的比较字符串第二个字母，以此类推）输出的S1和S2并集的字符串。

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner (System.in);
String s=sc.nextLine();
String[] ns=s.split(" ");//分割成独立的单词
Set<String> s1=new TreeSet<String>();//建立集合1，2
Set<String> s2=new TreeSet<String>();

for(int i=0;i<ns.length;i++)//放入字符串
{if(s1.size()<5){
s1.add(ns[i]);
continue;}
if(s2.size()<5){
s2.add(ns[i]);
continue;
}}
s1.addAll(s2);
Iterator it=s1.iterator();//迭代器访问s1集合
while(it.hasNext())//执行迭代器必备
System.out.println(it.next());}}

1）从键盘录入多行学生成绩的信息，每行表示一个学生的一门课的成绩，最后一行以“exit”结束。每行文本的格式为：学号,姓名,课程名,成绩。程序能够读取学生及其成绩，将具有相同学号的学生及其成绩读取到一个Student（学生类）类对象的列表（List）stuList中；
2）程序在读取完学生及其成绩的数据后，能够将stuList中的学生按照平均成绩降序排列(如果平均成绩相同，学号数字小的排在前面)，并输出排序后的学生学号、姓名和成绩。

输入格式:

多行表示的学生成绩，每一行是一个学生的姓名、学号、课程名、成绩（整数）。不同行可以是同一名学生（学号相同的为同一名学生）不同课程的成绩。

输出格式:

按照学生平均成绩降序排序（平均成绩相同的学号小的在前面）的学生排名（具体输出格式参照样例）。

import java.util.*;
class Student implements Comparable<Student>{//接口比较，学生泛型
    private String name,id;
    private int subject=1;
    private int score;
    private double sum=0;
    Student(){}//空参构造函数
    Student(String name,String id,int score){
             this.name=name;
             this.id=id;
             this.score=score;
    }//作用等于set
    public String getid(){
        return this.id;
    }
    public void subjectadd() {
        this.subject++;
    }
    public void scoreadd(int score){
        this.score=this.score+score;
    }
    public String getname() {
        return this.name;
    }
    public void sum() {
        this.sum=this.score/this.subject;
    }
  

    public int compareTo(Student o1){//比较
               Student one = (Student) o1;
               if(this.sum-one.sum!=0)
               return (int)(one.sum-this.sum);
               else
               return this.id.compareTo(one.id);
    }
}
public class Main{//主函数
    public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            List<Student> list =new ArrayList<Student>();//建列表
            int i,flag=0;
            String k;
            String[] and =new String[5];//

            while(sc.hasNext())
            {
                k=sc.next();
                and=k.split(",");
                if(k.compareTo("exit")==0)
                break;
                for(i=0;i<list.size();i++)
                {
                    if(list.get(i).getid().compareTo(and[1])==0)
                    {
                        flag=1;
                        break;
                    }
                }
                if(flag==1)
                {
                    list.get(i).subjectadd();
                    list.get(i).scoreadd(Integer.parseInt(and[3]));
                }
                else
                {
                    list.add(new Student(and[0],and[1],Integer.parseInt(and[3])));
                }
                flag=0;
            }
            for(i=0;i<list.size();i++)
            list.get(i).sum();
            Collections.sort(list);
            for(i=0;i<list.size();i++)
            {
                
                System.out.println("No"+(i+1)+":"+list.get(i).getid()+","+list.get(i).getname());
                //System.out.println(list.get(i).rescore());
            }

    }
}

求整数集合A与整数集合B的交集。

输入格式:

输入有三行：

第一行是A和B的元素个数m和n（m,n <=100）；

第二行是集合A的m个元素；

第三行是集合A的n个元素。

输出格式:

输出交集的所有元素（按照在A集合出现的顺序输出，最后一个输出后面没有空格）。
若交集为空，输出“NULL”。

import java.util.*;

public class Main {
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);	
    	int m = sc.nextInt();
    	int n = sc.nextInt(); //m,n 接受
    	List<Integer> s1 = new ArrayList<>();
    	List<Integer> s2 = new ArrayList<>();//集合准备
    	for(int i = 0; i < m; i++)
    		s1.add(sc.nextInt());
    	for(int i = 0; i < n; i++)
    		s2.add(sc.nextInt());//集合到位能
    	boolean f = false;
    	boolean first = true;
    	for(int x : s1) {
    		if(s2.contains(x)) {
    			f = true;
    			if(first) {System.out.print(x); first = false;}
    			else System.out.print(" " + x);
    		}
    	}
    	if(!f) System.out.println("NULL");//f是假，s2不包含
    	else System.out.println("");
    }
}

另一种做法（因为boolean那里太绕了

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main{
	 public static void main(String[] args){
		 	Scanner sc = new Scanner(System.in);
	   		int m=sc.nextInt();
	   		int n=sc.nextInt();
	   		int[] a=new int[m];
	   		int[] b=new int[n];
	   		int flag=0;
	   		for(int i=0;i<m;i++) {
	   			a[i]=sc.nextInt();
	   		}
	   		for(int i=0;i<n;i++) {
	   			b[i]=sc.nextInt();
	   		}
	   		for(int i=0;i<m;i++) {
	   			for(int j=0;j<n;j++) {
	   				if(a[i]==b[j]) {//有一样的
	   					flag++;
	   					if(flag==1) {
	   						System.out.print(a[i]);
	   					}
	   					else System.out.print(" "+a[i]);
	   				}
	   			}
	   		}
	   		if(flag==0)
	   			System.out.println("NULL");
	 }
}

输入3个整数n、begin、end。
首先，使用如下代码：

for(int i=0;i<n;i++)

将从0到n-1的数字拼接为字符串str。如，n=12，则拼接出来的字符串为01234567891011

最后截取字符串str从begin到end(包括begin，但不包括end)之间的字符串，并输出。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n, begin, end;
            n = scanner.nextInt();
            begin = scanner.nextInt();
            end = scanner.nextInt();
            StringBuilder str = new StringBuilder("");//建立可修改的字符串
            for (int i = 0; i < n; i++) {
                str.append(i);//填入
            }
            System.out.println(str.substring(begin,end));//截取
        }

    }
}

1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()

2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。
toString方法(Eclipse自动生成)

3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与
double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。

4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。 提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;

注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main (String [] args) {

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();

        //存储每个形状的实例，用于之后的输出各个形状的信息
        Shape [] shapes = new Shape[n];

        for (int i = 0; i < n; i++) {

            String str = scanner.next();

            if ("rect".equals(str)) {

                Rectangle rectangle = new Rectangle(scanner.nextInt(), scanner.nextInt());
                shapes[i] = rectangle;
                Shape.sumAllArea(rectangle);
                Shape.sumAllPerimeter(rectangle);
            } else if ("cir".equals(str)) {

                Circle circle = new Circle(scanner.nextInt());
                shapes[i] = circle;
                Shape.sumAllArea(circle);
                Shape.sumAllPerimeter(circle);
            }
        }
        scanner.close();

        //输出所有形状的周长之和
        System.out.println(Shape.sumAllPerimeter());
        //输出所有形状的面积之和
        System.out.println(Shape.sumAllArea());
        //输出所有形状的信息
        System.out.println(Arrays.toString(shapes));

        //输出每个形状的类型及其父类型
        for (int i = 0; i < n; i++) {
            System.out.print(shapes[i].getClass() + ",");
            System.out.println(shapes[i].getClass().getSuperclass());
        }
    }
}


abstract class Shape {

    final static double PI = 3.14;

    /**
     * 存所有形状的面积之和
     * */
    private static double area = 0.0;

    /**
     * 存所有形状的周长之和
     * */
    private static double perimeter = 0.0;

    /**
     * 返回该形状的周长
     * */
    public abstract double getPerimeter();
    /**
     * 返回该形状的面积
     * */
    public abstract double getArea();

    public abstract String toString();


    static double sumAllArea() {
        return area;
    }

    static void sumAllArea(Rectangle rect) {
        area += rect.getArea();
    }

    static void sumAllArea(Circle cir) {
        area += cir.getArea();
    }


    static double sumAllPerimeter() {
        return perimeter;
    }

    static void sumAllPerimeter(Rectangle rect) {
        perimeter += rect.getPerimeter();
    }

    static void sumAllPerimeter(Circle cir) {
        perimeter += cir.getPerimeter();
    }


}


class Rectangle extends Shape {

    private int width;
    private int length;

    Rectangle(int width, int length) {
        this.width = width;
        this.length = length;
    }


    public double getPerimeter() {
        return 2 * (width + length);
    }


    public double getArea() {
        return width * length;
    }


    public String toString() {//字符串形式
        return "Rectangle [width=" + width + ", length=" + length + "]";
    }

}


class Circle extends Shape {//继承

    private int radius;

    Circle (int radius) {
        this.radius = radius;
    }


    public double getPerimeter() {
        return 2 * PI * radius;
    }


    public double getArea() {
        return  PI * radius * radius;
    }


    public String toString() {
        return "Circle [radius=" + radius + "]";
    }
}

有若干大整数，需要对其进行求和操作。

输入格式

每行输入一个字符串代表一个大整数，连续输入若干行，当某行字符为e或E时退出。

import java.util.*;
import java.util.BigInteger;
public class Main{
   public static void main(String[] args) {
        Scanner s=new Scanner (System.in);
            String bignum=s.nextLine();
    BigInteger sum= new BigInteger("0");
        while(true){
            if(bignum.equals(e)||bignum.equals(E))
                break;
            
            BigInteger bignum = new BigInteger(bignum);
            sum=sum.add(bignum);
            String bignum=s.nextLine();
            
        }
        System.out.println(sum);
    }
}

要求统计一个整型序列中出现次数最多的整数及其出现次数。

输入格式:

在一行中给出序列中整数个数N（0<N≤1000），依次给出N个整数，每个整数占一行。

输出格式:

在一行中输出出现次数最多的整数及其出现次数，数字间以空格分隔。题目保证这样的数字是唯一的。

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        HashMap<Integer,Integer> m = new HashMap<>();
        int n = cin.nextInt();
        for(int i = 0;i < n;i++){
            int x = cin.nextInt();
            if(m.containsKey(x)){//有包含
                m.put(x,m.get(x)+1);
            }
            else{
                m.put(x,1);
            }
        }
        int k = 0,sum = 0;
        for(Map.Entry<Integer,Integer> entry: m.entrySet()){
            int x = entry.getKey();
            int y = entry.getValue();
            if(y > sum){
                k = x;
                sum = y;
            }
        }
        System.out.println(k+" "+sum);
    }
}

该程序包含

Person类

属性：String name,boolean gender String birthdate。

构造方法：

无参构造方法（初始化名字为空字符串，gender为false）
两个参数的构造方法(name,gender)
三个参数的构造方法(name,gender,birthdate)

方法：getter/setter方法。

自定义接口Judgeable

方法：boolean judge(String)

main类

静态方法：int countPerson(List,Judgeable)，功能为调用List集合中所有元素的judge方法，并统计其中返回true的元素个数。

main方法:

定义一个Person类集合，输入个数n，在下面依次输入n行的name,gender，biryhDate值生成person对象并添加进集合。

判断集合中name长度为5的数的个数，并输出，具体格式见输出样例。

判断集合中name长度为7的数的个数，并输出，具体格式见输出样例。

判断集合中name为空的个数，并输出，具体格式见输出样例。

输入格式:

输入一个整数number

根据number，输入number行的name,gender,birthDate

输出格式：

name长度为5的名字的个数

name长度为7的名字的个数

name为null的个数

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Person {
    String name;
    boolean gender;
    String birthdate;

    Person(){//初始化
        this.name = "null";
        this.birthdate = "";
        gender = false;
    }

    Person(String name, boolean gender){
        this.name = name;
        this.gender = gender;
    }

    Person(String name, boolean gender, String birthdate){
        this.name = name;
        this.gender = gender;
        this.birthdate = birthdate;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setBirthdate(String birthdate) {
        this.birthdate = birthdate;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public String getBirthdate() {
        return birthdate;
    }

    public boolean isGender() {
        return gender;
    }
}

interface Judgeable{//自定义接口
    boolean judge(String s);
    static int countPerson(List<Person> personList, Judgeable judger){
        return 0;
    }
}

//在这里给出Judgeable接口的定义，入参为String，返回boolean。

public class Main {

    public static int countPerson(List<Person> personList, Judgeable judger) {
        int n = 0;
        for (Person person : personList) {
            if (judger.judge(person.getName()))
                n++;
        }
        return n;
    }


    public static void main(String[] args) {//主函数
        Scanner sc = new Scanner(System.in);
        List<Person> personList = new ArrayList<Person>();
        String name;
        boolean gender;
        String  birthDate;

        //在这里输入个数
        int num = sc.nextInt();

        //循环创建person对象存入personList最后
        for(int i = 1; i <= num; i++){
            name = sc.next();
            gender = sc.next()=="true"?true:false;
            birthDate = sc.next();
            Person p = new Person(name, gender, birthDate);
            personList.add(p);
        }
        //注意：当name输入为null时，将其置为空

        int nameLength5 = countPerson(personList, new Judgeable() {
            //Judgeable的实现代码

            @Override
            public boolean judge(String s) {
                return s.length() == 5;
            }
        });

        System.out.println("Number of person with nameLength == 5:"+nameLength5);
        int nameLength7 = countPerson(personList, new Judgeable() {
            //Judgeable的实现代码

 
            public boolean judge(String s) {
                return s.length() == 7;
            }
        });

        System.out.println("Number of person with nameLength == 7:"+nameLength7);
        int nameisnull = countPerson(personList, new Judgeable() {
            //Judgeable的实现代码


            public boolean judge(String s) {
                return s.equals("null");
            }
        });

        System.out.println("Number of person with null name:"+nameisnull);
    }
}

输入一篇英文文章，碰到"!!!!!"的时候停止，输出文章中出现的不重复单词的个数(注意：单词不区分大小写，如：The和the为一个单词)

输入格式:

一篇英文文章，以"!!!!!"结尾

输出格式:

不重复单词的个数

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
 
public class Main{
    public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Set <String> set=new HashSet <String>();
        while(true){
        String  aString=in.next();
        if(aString.equals("!!!!!")){
            break;
        }
set.add(aString.toLowerCase());//转小写判断
    	}
    System.out.println(set.size());
}}

要求从键盘读取输入的整数成绩，由百分制转换成五分制输出结果。[0,60）不及格，[60,70)及格，[70,80)中，[80,90)良，[90,100]优，其余显示为：成绩不正确。

输入格式:

输入一个整数形式的百分制成绩。

输出格式:

输出相应的五分制成绩。


import java.util.Scanner;
public class Main {
  
  public static void main(String[] args) {
	  Scanner input=new Scanner(System.in);
	  int source=input.nextInt();
	  if(0<=source&&source<=100) {
	  switch(source/10) {
	  case 6:
		  System.out.print("及格");
		  break;
	  case 7:
		  System.out.print("中");
		  break;
	  case 8:
		  System.out.print("良");
		  break;
	  case 9:
		  System.out.print("优");
		  break;
	  case 10:
		  System.out.print("优");
		  break;
	 default:
		 System.out.print("不及格");
	  }}else System.out.print("成绩不正确");
	  
	  
  } 

}

提示：在Java中利用Math类的方法——**Math.sqrt()**求平方根。

java.lang.Math.sqrt(double a) 返回一个double值的正平方根。

输入格式:

输入有若干行，每行有2个数值，分别表示直角三角形的两个直角边长度，用空格分隔。

输出格式:

对应每行输入数据，输出直角三角形的斜边长度，结果保留2位小数。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int i=1;
        while(scanner.hasNext()) {
            double a=scanner.nextDouble();
            double b=scanner.nextDouble();
            System.out.printf("%.2f\n", Math.sqrt(a*a+b*b));
        }
    }
}

public class Main {
    public static void main(String[] args) {
        for(int i=100;i<1000;i++){
            int a=i/100;
            int b=i/10%10;
            int c=i%10;
            if(Math.pow(a, 3)+Math.pow(b, 3)+Math.pow(c, 3)==i){
                System.out.println(i);
            }
        }
    }
}

大家都知道一些办公软件有自动将字母转换为大写的功能。输入一个长度不超过 100 且不包括空格的字符串。要求将该字符串中的所有小写字母变成大写字母并输出。

输入格式:

输入一个长度不超过 100 且不包括空格的字符串。

输出格式:

将该字符串中的所有小写字母变成大写字母并输出。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        char[] array=str.toCharArray();//字符串转字符数组
        for (int i = 0; i < array.length; i++) {
            if (array[i] >='a' && array[i] <= 'z') {
                array[i] = (char) (array[i] - ('a' - 'A'));//别忘了转换数据类型
            }
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
        }
    }
}

实验要求：设计类Rectangle，定义必要的属性和方法，要求包含两个构造方法，至少实现求面积、求周长并进行测试。

输入格式:

输入两个边长。

输出格式:

对每一组输入，在一行中输出面积的值和周长的值。

import java.util.Scanner;
class Rectangle{
    private int width;
    private int length;
    public Rectangle(){//无参函数初始化
        width=1;
        length=1;
    }
    public Rectangle(int w,int l){
        width=w;
        length=l;
    }
    public int area(){
        int area=width*length;
        return area;
    }
    public int perimeter(){
        int perimeter=2*width+2*length;
        return perimeter;
    }
}
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        Rectangle a1=new Rectangle(in.nextInt(),in.nextInt());
        System.out.printf("%d %d",a1.area(),a1.perimeter());
    }
}

利用之前完成的类Rectangle，编写子类Square，实现正方形的求面积和求周长功能，并进行测试。

输入格式:

输入整数边长。

输出格式:

对每一组输入，在一行中输出面积和周长的值。

import java.util.Scanner;
class Rectangle{
    private int width;
    private int length;
    public Rectangle(){
        width=1;
        length=1;
    }
    public Rectangle(int w,int l){
        width=w;
        length=l;
    }
    public int area(){
        int area=width*length;
        return area;
    }
    public int perimeter(){
        int perimeter=2*width+2*length;
        return perimeter;
    }
}
class Square extends Rectangle{//子类
    private int b;
    public Square(){
        b=1;
    }
    public Square(int bian){
        b=bian;
    }
    public int area(){
        int area=b*b;
        return area;
    }
    public int perimeter(){
        int perimeter=4*b;
        return perimeter;
    }
}
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        Square c=new Square(in.nextInt());
        System.out.printf("%d %d",c.area(),c.perimeter());
    }
}

从键盘接收用户输入的两个字符串，第一个代表用户名，第二个代表密码。

(1)如果用户名是SwpuIot，并且密码是123456，则输出：Welcome

(2)如果用户名正确，密码不正确，输出：Mismatch

(3)其他情况下，输出：NotExist

要输出的信息，建议从题目中复制，确保精确匹配。

输入格式:

用空格分隔开的两个字符串。

输出格式:

首字母大写的一个单词或词组。

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
        	  Scanner input=new Scanner(System.in);
		String str = "SwpuIot 123456";
		String[] strs = str.split(" ");
		
		Scanner sc = new Scanner(System.in);
		String s1 = sc.next();
		String s2 = sc.next();//分割完了，当两个不同的数看
		sc.close();
		
		if(strs[0].equals(s1) && strs[1].equals(s2)) {//三种情况
			System.out.println("Welcome");
		}else if(strs[0].equals(s1) && !strs[1].equals(s2)) {
			System.out.println("Mismatch");
		}else {
			System.out.println("NotExist");
		}
		
	}
}

编写一个程序，统计一个子串在整串中出现的次数，例如子串“nba”在整串“nbaabcdefnbaxyzmba”中出现的次数为2。要求使用String或者StringBuffer类的常用方法来计算出现的次数。

请注意：含有main方法的类（class）的名字必须命名为Main，否则调试不成功。

输入格式:

输入两行，每行输入一个字符串。第一个当作整串，第二个当作子串。每个字符串的中间不要出现换行符（Enter）、空格、制表符（Tab）。

输出格式:

输出子串在整串中出现的次数，结果是一个大于或等于0的整数。

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        String a=in.next();
        String b=in.next();
        int index=0;
        int count=0;
        while(true)
        {
            index=a.indexOf(b)；//寻找
            if(index!=-1)
            {
                count++;//出现
                a=a.substring(index+b.length());//去除已查找片段
            }
            else
            {
                break;
            }
        }
        System.out.println(count);
        
    }
}

找出10个整数中的最大值、最小值、偶数的个数、偶数的平均值。（使用Scanner类从键盘输入数据。）

请注意：含有main方法的类（class）的名字必须命名为Main，否则调试不成功。

输入格式:

在一行中输入10个整数，中间用空格隔开。

输出格式:

分四行分别输出最大值、最小值、偶数的个数、偶数的平均值。

import java.util.Arrays;
import java.util.Scanner;
class Main{
    public static void main(String []args)
    {
        Scanner in=new Scanner(System.in);
        int a[]=new int[10];
        if(in.hasNext())
        {
            for(int i=0;i<10;i++)
            {
                a[i]=in.nextInt();
            }
        }
       Arrays.sort(a);
        System.out.println("最大值是"+a[9]);
        System.out.println("最小值是"+a[0]);
        int b[]=new int[10];
        int count=0;
        int sum=0;
        int count1=0;
        for(int i=0;i<a.length;i++)
        {
            if(a[i]%2==0)
            {
                count++;
                sum+=a[i];
            }
        }
   
        System.out.println("偶数的个数是"+count);
        if(count!=0)
        {
        System.out.printf("偶数的平均值是%.1f",(sum*0.1)/(count*0.1));
        }
        else
        {
            System.out.println("偶数的平均值是0.0");
        }
        }
}

对10个整数进行排序。（使用Scanner类从键盘输入数据。）

请注意：含有main方法的类（class）的名字必须命名为Main，否则调试不成功。

输入格式:

在一行中输入10个整数，中间以空格隔开。

输出格式:

按从小到大的顺序输出这10个整数，中间以一个空格隔开（最末尾不要空格）。

import java.util.Scanner;
import java.util.Arrays;
class Main{
    public static void main(String []args)
    {
        Scanner in=new Scanner(System.in);
        int a[]=new int[10];
        if(in.hasNext())
        {
            for(int i=0;i<10;i++)
            {
                a[i]=in.nextInt();
            }
            
        }
        Arrays.sort(a);//真正有用的排序
        for(int i=0;i<a.length;i++)//两种情况
        {
            if(i==0)
            {
            System.out.print(a[0]);
            }
            else{
            System.out.print(" "+a[i]);
            }
        }
    }
}

学术会议地点统计问题

秘书统计张教授【以后简称 z 】和王教授【以后简称 w 】上一年度参加学术会议的情况，教授详细行程清单如下：

z:bj 3,hz 2,qd 4,nj 5,wh 3,bj 3

w:hn 7,xm 6,bj 4,gz 6,wh 4

现在秘书需要完成以下统计工作。
找出两位教授共同去过的城市，并找出住宿天数长的教授，按照如下格式输出：

z:bj 6,w:wh 4

请同学们编写代码帮助搞定。

import java.awt.*;
import java.util.*;
import javax.swing.JPanel;

import java.io.*;

public class Main {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String sz = scan.nextLine();
		String sw = scan.nextLine();
		TreeMap<String, Integer> mapz = new TreeMap<>();
		TreeMap<String, Integer> mapw = new TreeMap<>();
		TreeMap<String, Integer> mapzz = new TreeMap<>();
		TreeMap<String, Integer> mapww = new TreeMap<>();
		sz = sz.substring(2);//返回字符串的子字符串
		sw = sw.substring(2);
		String[] szz = sz.split(",");//分开
		String[] sww = sw.split(",");
		for (String str : szz) {//对于z教授
			String[] strr = str.split(" ");
			if (mapz.containsKey(strr[0])) {//哈希找映射
				mapz.put(strr[0], mapz.get(strr[0]) + Integer.parseInt(strr[1]));
			} else {
				mapz.put(strr[0], Integer.parseInt(strr[1]));
			}

		}

		for (String str : sww) {
			String[] strr = str.split(" ");
			if (mapw.containsKey(strr[0])) {
				mapw.put(strr[0], mapw.get(strr[0]) + Integer.parseInt(strr[1]));
			} else {
				mapw.put(strr[0], Integer.parseInt(strr[1]));
			}
		}
		
		boolean fg = false;
		for (Map.Entry<String, Integer> entry : mapz.entrySet()) {
			if (mapw.containsKey(entry.getKey())) {
				fg = true;
				if (entry.getValue() >= mapw.get(entry.getKey())) {
					mapzz.put(entry.getKey(), entry.getValue());
				} else {
					mapww.put(entry.getKey(), mapw.get(entry.getKey()));
				}
			}
		}
		
		int i = 0;
		int j = 0;
		if (fg) {
			if (mapzz.size() != 0) {
				for (Map.Entry<String, Integer> entry : mapzz.entrySet()) {
					System.out.print("z:");
					System.out.print(entry.getKey() + " " + entry.getValue());
					i++;
					if (i != mapzz.size()) {
						System.out.print(",");
					}
				}
			}
			if (mapzz.size() != 0 && mapww.size() != 0) {
				System.out.print(",");
			}
			if (mapww.size() != 0) {
				for (Map.Entry<String, Integer> entry : mapww.entrySet()) {
					System.out.print("w:");
					System.out.print(entry.getKey() + " " + entry.getValue());
					j++;
					if (j != mapww.size()) {
						System.out.print(",");
					}
				}
			}
		} else {
			System.out.println("none");
		}
	}
}

编写一个程序进行一个班某门课程成绩的录入，能够控制录入成绩总人数，对录入成绩统计其及格人数和不及格人数。设计一个异常类，当输入的成绩小0分或大于100分时，抛出该异常类对象，程序将捕捉这个异常对象，并调用执行该异常类对象的toString（）方法，该方法获取当前无效分数值，并返回一个此分数无效的字符串。

输入格式:

从键盘中输入学生人数n

从键盘中输入第1个学生的成绩

从键盘中输入第2个学生的成绩

...

从键盘中输入第n个学生的成绩

（注：当输入的成绩无效时（即分数为小于0或大于100）可重新输入，且输出端会输出此分数无效的提醒。）

输出格式:

显示及格总人数

显示不及格总人数

import java.util.Scanner;
 
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k1 = 0, k2 = 0;
		for (int i = 0; i < n; i++) {
			int x = in.nextInt();
			if (x < 0 || x > 100) {
				i--;
				System.out.println(x + "invalid!");
			} else if (x > 0 && x < 60)
				k1++;
			else
				k2++;

		}
		System.out.println(k2);
		System.out.println(k1);
 
	}
}
 
class err extends Exception {
 
}//继承不重写

构造计算机类，其中包含其配置信息：处理器、主板、内存、显示器、硬盘等设备，各个设备均有型号（字符串），特别的，处理器有主频（小数）和内核数（整数）、显示器有尺寸（整型）、内存和硬盘有容量数据（GB为单位）。请你尝试构造合适的类和类的关系来表示计算机，并为该计算机类添加计算价格（各设备价格之和）、打印配置信息等方法。重写相关类的equals方法，使得两个配置完全相同的计算机为相同的计算机。重写相关类的toString函数，打印计算机的配置信息。
在main函数中

提示：
为计算机类和各个组成配件都构造类，分别重写toString和equals方法
在计算机类中调用各个配件的equals和toString方法
回车用\n
小数用String.format("%.1f",1.234)

输入格式:

两个计算机对象，包含
CPU：型号、主频、内核
主板：型号
内存：容量
显示器：尺寸
硬盘：容量

输出格式:

两个对象是否相等
两个对象的配置信息

import java.util.Scanner;

class Disk{
	String model ;
	int size;

	public Disk(){
		this.init();
	}

	public Disk(String model , int size ){
		this.model = model;
		this.size = size;
	}

	private void init(){
		this.model = "";
		this.size = 0;
	}

	public String printInfo(){
		return "Harddisk:\nModel: " + this.model +
			   "\nSize: " + this.size + "\n" ;
	}
}

class Display{
	String model ;
	int size;

	public Display(){
		this.init();
	}

	public Display(String model , int size){
		this.model = model;
		this.size = size;
	}

	private void init(){
		this.model = "";
		this.size = 0;
	}

	public String printInfo(){
		return "Screen:\nModel: " + this.model +
			   "\nSize: " + this.size + "\n" ;
	}
}

class RAM{
	String model ;
	int size;

	public RAM(){
		this.init();
	}

	public RAM(String model,int size ){
		this.model = model ;
		this.size = size;
	}

	private void init(){
		this.model = "";
		this.size = 0;
	}

	public String printInfo(){
		return "Memory:\nModel: " + this.model +
			   "\nSize: " + this.size + "\n" ;
	}

}

class MotherBoard{
	String model ;

	public MotherBoard(){
		this.init();
	}
	public MotherBoard(String model){
		this.model = model;
	}

	private void init(){
		this.model = "";
	}

	public String printInfo(){
		return "Mainboard:\nModel: " + this.model + "\n" ;
	}

}

class CPU{
	String model ;
	double clockSpeed;
	int coreCount;

	public CPU(){
		this.init();
	}

	public CPU(String model, double cS,int cC){
		this.model = model;
		this.clockSpeed = cS;
		this.coreCount = cC;
	}

	private void init(){
		this.model = "";
		this.clockSpeed = 0.0;
		this.coreCount = 0;
	}
	public String printInfo(){
		return "CPU:\nModel: " + this.model +
			"\nFrequency: " + this.clockSpeed +
			"\nNumber of Cores: " + this.coreCount + "\n" ;
	}
}

class Computer{
	String info ;
	CPU cpu;
	MotherBoard motherboard;
	RAM ram;
	Display display;
	Disk disk;


	
	public Computer(Scanner in){
		

		this.info = "";
		this.cpu = new CPU(in.next(), in.nextDouble(), in.nextInt());
		this.motherboard = new MotherBoard(in.next() );
		this.ram = new RAM(in.next(), in.nextInt());
		this.display = new Display(in.next(), in.nextInt() );
		this.disk = new Disk(in.next(), in.nextInt() );


	}

	public String toString(){
		return  cpu.printInfo() +
				motherboard.printInfo() +
				ram.printInfo() +
				display.printInfo() +
				disk.printInfo();
	}



	public boolean equals(Object ob){
		if( (ob == null) || !(ob instanceof Computer) ){
			return false;		
		}
		return ( this.toString().equals(ob.toString()) );
	}
}

public class Main{
	public static void main(String []arg){

		Scanner in = new Scanner(System.in);
		Computer c1 = new Computer(in),
				 c2 = new Computer(in);


		System.out.println( c1.equals(c2) );	
		System.out.println("Computer1:");	 
		System.out.print( c1.toString());
		System.out.println("Computer2:");	 
		System.out.print( c2.toString() );
	}
}

构建一个书类Book，包括名称（字符串），价格（整型），作者（字符串，多个作者当做一个字符串处理），版本号（整型），提供带参数的构造函数Book(String name, int price, String author, int edition)，提供该类的toString()和equals()方法，toString方法返回所有成员属性的值的字符串形式，形如“name: xxx, price: xxx, author: xxx, edition: xxx”，当两个Book对象的名称(不关心大小写，无空格)、作者(不关心大小写，无空格)、版本号相同时，认为两者表示同一本书。
Main函数中，读入两本书，输出他们是否相等，打印两本书的信息。

输入描述：

两本书信息

输出描述：

两本书的打印信息
两本书是否相等

裁判测试程序样例：略

 class Book {
    String name;
    int price;
    String author;
    int edition;

    public Book(String name, int price, String author, int edition) {
        this.name = name;
        this.price = price;
        this.author = author;
        this.edition = edition;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getEdition() {
        return edition;
    }

    public void setEdition(int edition) {
        this.edition = edition;
    }

    public String toString() {
        return "name: " + this.name +
                ", price: " + this.price +
                ", author: " + this.author +
                ", edition: " + this.edition;
    }

    public boolean equals(Object o) {
        //if (this == o) return true;
        if (o == null) return false;
        else {
            boolean result = false;
            if (o instanceof Book) {
                Book book = (Book) o;
                //当两个Book对象的名称(不关心大小写，无空格)、作者(不关心大小写，无空格)、版本号相同时，认为两者表示同一本书。注意此处无关价格
                if (book.name.equalsIgnoreCase(this.name)&&book.author.equalsIgnoreCase(this.author)&&book.edition==this.edition)
                    result = true;
            }
            return result;
        }
    }
}

给定两个整型数组A和B，将A的元素复制到B中，使得两个数组完全相同。再将B数组从小到大排列，将两数组的同一位置上对应的元素进行比较，统计出A中大于B的元素个数，等于B中元素的个数，小于B中的元素的个数。
提示：可用Arrays.sort排序

输入格式:

数组A的个数
数组A元素

输出格式:

A大于B的个数
A等于B的个数
A小于B的个数

import java.util.*;
 
public class Main{
 
    public static void main(String[] args) {
 
    Scanner scan = new Scanner(System.in);
 
    int num = scan.nextInt();
 
    int BigNum = 0;
 
    int EqualNum = 0;
 
    int SmallNum = 0;
 
    int ArrayA[] = new int[num];
 
    int ArrayB[] = new int[num];
 
    for(int i = 0;i < num; i++) {
 
        ArrayA[i] = scan.nextInt();
 
  
 
    }
 
    System.arraycopy(ArrayA, 0, ArrayB, 0, num);
 
    Arrays.sort(ArrayB);
 
    for(int i = 0; i < num;i++) {
 
        if(ArrayA[i] > ArrayB[i]) {
 
            BigNum ++;
 
        }
 
        else if(ArrayA[i] == ArrayB[i]) {
 
            EqualNum ++;
 
        }
 
        else if(ArrayA[i] < ArrayB[i]) {
 
            SmallNum ++;
 
        }
 
    }
 
    System.out.println(BigNum);
 
    System.out.println(EqualNum);
 
    System.out.println(SmallNum);
 
 }
 
}

数组元素交换，要求：（1）最大的元素与第一个元素交换（2）最小的元素与最后一个元素交换。

输入格式:

输入一行字符串（由不同的整数组成，以空格分开）

输出格式:

首先以数组形式输出初始字符串（一行一个数字），然后以数组形式输出完成交换后的字符串（一行一个数字）。

class SwapTest{
	public static <T extends Comparable<T>>void swap(T[] temp){//泛型+接口
		T min=temp[0];
		T max=temp[0];
		for(int i=0;i<temp.length;i++){
			if(min.compareTo(temp[i])>0){
				min=temp[i];
			}
			if(max.compareTo(temp[i])<0){
				max=temp[i];
			}
		}
		swapFirst(max,temp);
		swapLast(min,temp);
	}
	public static <T>void swapFirst(T t,T[] temp){
		for(int i=0;i<temp.length;i++){
			if(temp[i]==t){
				T data=temp[i];
				temp[i]=temp[0];
				temp[0]=data;
			}
		}
		
	}
	public static <T>void swapLast(T t,T[] temp){
		for(int i=0;i<temp.length;i++){
			if(temp[i]==t){
				T data=temp[i];
				temp[i]=temp[temp.length-1];
				temp[temp.length-1]=data;
			}
		}
		
	}
}
public class Swap {
	public static void main(String[] args) {
		Integer[] data=new Integer[]{1,2,3,6,3,10,70,4,9};
		SwapTest.swap(data);
		for(int x=0;x<data.length;x++){
			System.out.println(data[x]);
		}
	}
}

1.本题目要求得的两个向量的和，每一个向量通过一个一维数组表示，具体要求为：

1在Main类中.创建一个方法，方法功能为求两个一维数组之和得到求和数组并返回。方法声明为：

public static int[] add(int arr[],int []arr2)

2.在main方法中创建两个一维数组，一维数组的长度通过键盘得到，数组的元素通过键盘输入。

3.调用add方法得到两个一维数组之和，并输出这个一维数组的值。

输入格式:

第一行输入数组的元素个数
第二行输入第一个数组的各个元素中间以空格隔开
第三行输入第二个数组的各个元素中间以空格隔开

输出格式:

输出求和数组的各个元素，每行输出一个元素。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {//主函数
        Scanner scanner = new Scanner(System.in);
        int len;//数组长度
        int sum[];//求和后的数组
        len = scanner.nextInt();
        int arr[] = new int[len];
        int arr2[] = new int[len];
        for(int i=0;i<len;i++){
            arr[i] = scanner.nextInt();
        }
        for(int i=0;i<len;i++){
            arr2[i] = scanner.nextInt();
        }
        //求和
        sum = add(arr,arr2);
        //输出
        for(int i=0;i<len;i++){
            System.out.println(sum[i]);
        }
    }
    public static int[] add(int arr[],int arr2[]){//自定义add函数
        int []tmp = new int [arr.length];
        for(int i=0;i<arr.length;i++){//求和
            tmp[i] = arr[i] + arr2[i];
        }
        return tmp;
    }
}

本题运行时要求键盘输入10个人员的信息（每一个人信息包括：姓名，性别，年龄，民族），要求同学实现一个函数，统计民族是“汉族”的人数。

函数接口定义：

public static int numofHan(String data[])

其中 data[] 是传入的参数。 data[]中的每一个元素都是一个完整的人员信息字符串，该字符串由“姓名，性别，年龄，民族”，各项之间用英文半角的逗号分隔。函数须返回值是汉族的人数。

public static int numofHan(String data[]){
	String str = "汉族";
	int ans = 0;
	for(String s: data){
		if(s.indexOf(str, s.lastIndexOf(",")) != -1) {//从最后一个查找
			++ans;
		}
	}
	return ans;
}

编写程序，验证一个字符串是否为回文串：是否从前读它和从后读它都是一样的。例如，mom，dad是回文串。该程序接收用户输入的字符串，判断是否为回文串，然后将判断的结果输出。

输入格式:

输入在一行中给出一个字符串。

输出格式:

如果输入的字符串为回文串，则输出yes；否则输出no。

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
        String a = cin.nextLine();
        char[] str = a.toCharArray();
		int x=1;
		int len=a.length();
		for(int i=0;i<len/2;i++) {
			if(str[i]!=str[len-i-1]) {//正着数和倒着数
				x=0;

			}
		}
		if(x==1)
			System.out.println("yes");
		else
			System.out.println("no");
	}
}

给定一行字符串，去除其中的数字字符，并逆序输出。

输入格式:

输入一行字符串。

输出格式:

去除字符串中的数字字符，并逆序输出

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
String newStr = line.replaceAll("\\d+", "");//使用给定的参数替换字符串匹配的正则表达式的子串
StringBuffer buffer=new StringBuffer(newStr);//可对数组修改
System.out.println(buffer.reverse());//逆转
}
}