java上机作业

最新推荐文章于 2023-03-29 20:59:25 发布

怡人蝶梦

最新推荐文章于 2023-03-29 20:59:25 发布

阅读量1.3k

点赞数 3

分类专栏：计算机文章标签： java

本文链接：https://blog.csdn.net/yirenDM/article/details/124250025

版权

计算机专栏收录该内容

28 篇文章 2 订阅

订阅专栏

第一次

问题描述: 实现程序,找出一个数组中最大元素的最小下标值(假定数组中元素可以重复)

import java.util.Arrays;
import java.util.Random;
//import java.util.Scanner;

public class HomeWork1_1 {
    public static void main(String[] args){
        /* Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        int[] arr=random_number_maker(a,b);*/
        int[] arr=random_number_maker();
        System.out.println(Arrays.toString(arr));
        int index=0,result=arr[0];
        for(int i=0;i<arr.length;i++)
        {
            if(result<arr[i])
            {
                result=arr[i];
                index=i;
            }
        }
        System.out.println(index);
    }

        //public static int[] random_number_maker(int max,int length)
        public static int[] random_number_maker()
        {
            Random num=new Random();
            int[] s=new int[10];
            for(int i=0;i<s.length;i++)
            {
                int m=num.nextInt(10000);
                s[i]=m;
            }
            return s;
        }

    }

题目描述: 实现程序对于一个整型的二维数组,计算每一行的数字之和,记录数字之和最大的行序号并输出.

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class HomeWork1_2 {
    public static void main(String[] args){
        /*Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        int[][] num=new int[a][b];*/
        int[][] num=new int[10][10];
        Random random=new Random();
        int sum1=0,sum2=0,index=0;
        for(int i=0;i<10;i++)
        {
            for(int j=0;j<10;j++) {
                num[i][j] = random.nextInt(1000);
                sum1 += num[i][j];
            }
            if(sum1>sum2){

                sum2=sum1;
                sum1=0;
                index=i;
            }
        }
        for(int i=0;i<10;i++){
        System.out.println(Arrays.toString(num[i]));
        }
        System.out.println(index);

    }
}

第二次

问题描述: 实现插入排序算法(以整数或浮点数数组为输入,每次输入的数组内容随机生成,参考Random类)

import java.util.Random;
import java.util.Arrays;

public class HomeWork2 {
    public static void main(String[] args) {
        int[] a = new int[10];
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            a[i] = random.nextInt(10000);
        }
        System.out.println(Arrays.toString(a));
        InsertSort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void InsertSort(int[] b) {
        int i, j, insertNum;
        for (i = 1; i < b.length; i++) {
            insertNum = b[i];
            j = i - 1;
            while (j >= 0 && insertNum < b[j]) {
                b[j + 1] = b[j];
                j--;
            }
            b[j + 1] = insertNum;
        }
    }
}

第三次

题目3-2: 创建一个NewRectangle类，该类包含：
（1）double类型的成员变量width和height；
（2）默认构造方法（能够将width和height均置为0.0）；（3）带两个参数的构造方法（分别对width和height用参数进行初始化）；
（4）成员方法getArea()，返回矩形面积；（5）成员方法getPerimeter()，返回矩形周长。

package com.java.demo;

public class NewRectangle {
private double width,height;//(1)
 public NewRectangle(){}//(2)
public NewRectangle(double m,double n){
        width = m;
        height = n;
}//(3)
public  double getArea(){
        return width*height;
    }//(4)
    public double getPerimeter(){
        return 2*(width+height);
    }//(5)

题目3-3:(1）定义Point类，该类包含：①double类型的成员变量x和y，代
表点的坐标；②默认构造方法，将x和y置为0.0；③带两个参数的
构造方法，用于初始化x和y；④成员方法distance(Pointp)，返回当
前点与p所代表的点之间的距离。
（2）修改习题3-2实现的NewRectangle类，加入一个Point类型的
成员，代表矩形的左下角顶点的坐标。
（3）修改NewRectangle已有的两个构造方法，将构造出的矩形的左
下角顶点坐标设为(0.0,0.0)。再向NewRectangle中加入一个新的构造
方法，方法传入4个参数，分别对width、height、左下角顶点的x坐
标、左下角顶点的y坐标进行设置。
（4）向NewRectangle中加入一个新的成员方法：boolean
bPointIn(Pointp)，计算p所代表的点的坐标是否在矩形内部，如果在
内部则返回true，否则返回false。
（5）考虑：能否为NewRectangle实现成员方法，计算当前矩形是否
包含了另一个矩形，以及当前矩形是否与另一个矩形有重叠部分。如
果可以，请实现这些方法。

package com.java.demo;

public class NewRectangle {
    private double width,height;
    Point position=new Point();
    public NewRectangle(){}

    public NewRectangle(double m,double n){
        width = m;
        height = n;
        position.x=0.0;
        position.y=0.0;

    }
    public NewRectangle(double m,double n,double x,double y){
        width = m;
        height = n;
        position.x=x;
        position.y=y;
    }
    public  double getArea(){
        return width*height;
    }
    public double getPerimeter(){
        return 2*(width+height);
    }
    public boolean bPointIn(Point p,NewRectangle Object){
        if(p.x>=Object.position.x&&p.x<=Object.position.x+width&&p.y>=Object.position.y&&p.x<=Object.position.y+height){
            return true;
        }
        else
            return false;

    }
    public void is_include_or_overlap(NewRectangle Object1,NewRectangle Object2){

        if(Object1.getArea()>Object2.getArea()){
            Point p1=new Point(Object2.position.x,Object2.position.y);
            Point p2=new Point(Object2.position.x+width,Object2.position.y);
            Point p3=new Point(Object2.position.x,Object2.position.y+height);
            Point p4=new Point(Object2.position.x+width,Object2.position.y+height);
            if(bPointIn(p1,Object1)&&bPointIn(p2,Object1)&&bPointIn(p3,Object1)&&bPointIn(p4,Object1)){
                System.out.println("The first Rectangle"+" include the second Rectangle");
            }
            else if(bPointIn(p1,Object1)||bPointIn(p2,Object1)||bPointIn(p3,Object1)||bPointIn(p4,Object1)){
                System.out.println("Overlapping");
            }
            else{
                System.out.println("They are both independent");
            }
        }
        else{
            Point p1=new Point(Object1.position.x,Object1.position.y);
            Point p2=new Point(Object1.position.x+width,Object1.position.y);
            Point p3=new Point(Object1.position.x,Object1.position.y+height);
            Point p4=new Point(Object1.position.x+width,Object1.position.y+height);
            if(bPointIn(p1,Object2)&&bPointIn(p2,Object2)&&bPointIn(p3,Object2)&&bPointIn(p4,Object2)){
                System.out.println("The second Rectangle include the first Rectangle");
            }
            else if(bPointIn(p1,Object2)||bPointIn(p2,Object2)||bPointIn(p3,Object2)||bPointIn(p4,Object2)){
                System.out.println("Overlapping");
            }
            else{
                System.out.println("They are both independent");
            }
        }


    }
       public static void main(String[] args){
        NewRectangle M =new NewRectangle(10.3,11.27,10.0,10.0);
        NewRectangle N =new NewRectangle(10.3,11.27,100,100);
        System.out.println("Area="+M.getArea()+" Perimeter="+ M.getPerimeter());
        Point point=new Point(1,1);
        System.out.println(M.bPointIn(point,M));
        M.is_include_or_overlap(M,N);



    }
}
class Point{
    double x,y;
    Point(){

    }
    Point(double x,double y)
    {
        this.x=x;
        this.y=y;
    }
    public double distance(Point p){
        return Math.sqrt(p.x*p.x+p.y*p.y);
    }
}

第四次

题目描述:习题3-9：创建一个父类Cycle，再创建它的三个子类Unicycle、
Bicycle和Tricycle：
（1）在Cycle类中定义ride()方法，使得三个子类的实例都能通过方
法参数向上转型为Cycle类型。
（2）向Cycle类中加入wheel()方法，用于返回车轮数量。在Unicycle、
Bicycle、Tricycle中重写wheel()方法，返回具体的车轮数量。在ride()
方法中调用wheel()方法，输出参数所指向的对象的车轮数量，并说
明多态性的存在。
（3）在Unicycle和Bicycle类中添加方法balance()，在Tricycle中不
添加。在ride()方法中，尝试通过向下转型调用balance()方法，并使
用instanceof保证向下转型不会产生异常。

package com.java.demo;

public class Cycle {
    int wheels;
    public void ride(){
        Cycle[] cycle=new Cycle[3];
        cycle[0]=new Unicycle();
        cycle[1]=new Bicycle();
        cycle[2]=new Tricycle();
        for(int i=0;i<3;i++){
            System.out.println(cycle[i].wheel());
        }
        for(int i=0;i<3;i++) {
            if (cycle[i] instanceof Unicycle)
            {
                ((Unicycle)cycle[i]).balance();
            }
            if (cycle[i] instanceof Bicycle)
            {
                ((Bicycle)cycle[i]).balance();
            }
        }

    }
    public int wheel(){
        return wheels;
    }
    public static void main(String[] args){
        Cycle m=new Cycle();
        m.ride();

    }

}
class Unicycle extends Cycle{
    public int wheel(){
        return 1;
    }
    public void balance(){
        System.out.println("Unicycle.balance()");
    }

}
class Bicycle extends Cycle{
    public int wheel(){
        return 2;
    }
    public void balance(){
        System.out.println("Bicycle.balance()");
    }

}
class Tricycle extends Cycle{
    public int wheel(){
        return 3;
    }

}

第五次

问题描述：使用 LinkedList 实现一个类，该类有一个方法，该方法接受一个字符串作为参数，依次读取字符串中的字符，每次遇到“+” 时就将“+”后面的一个字符压入栈中，每次遇到“-”时就将当前栈顶的字符弹出并在控制台打印，直至字符串遍历完，最后输出栈上剩余内容。实现 main()方法调用这个方法，并传入字符串“+U+n+c— +e+r+t—+a-+i-+n+t+y—±+r+u–+l+e+s—”，观察输出。（注：“±”按先读入“+”时的语义处理）

package com.java.demo;

import java.util.LinkedList;
//import java.util.Stack;

public class LinkedList_Practice {
    LinkedList linkedList=new LinkedList();
//    Stack stack=new Stack();
    public void stringHanding(String str){
        for (int i = 0; i < str.length(); i++) {
            if(str.charAt(i)=='+'){
                linkedList.add(str.charAt(i+1));
//                stack.push(str.charAt(i+1));
                i++;
            }
            else if(str.charAt(i)=='-'){
                System.out.print(linkedList.getLast());
//                System.out.println(stack.peek());
//                stack.pop();
                linkedList.removeLast();
            }
        }
    }

    public static void main(String[] args) {
        String string="+U+n+c---\n" +
                "+e+r+t---+a-+i-+n+t+y---+-+r+u--+l+e+s---";
        LinkedList_Practice linkedListPractice=new LinkedList_Practice();
        linkedListPractice.stringHanding(string);

    }

}

第六次

问题描述：实现一个类 KeywordIdentifier，读入一个 java 程序源文件，输出各个关键字的个数（注意，注释中出现的关键字不计入关键字个数）。（注：对于跳过注释功能，仅要求支持单行注释的形式“//…”即可）
** 转载** https://blog.csdn.net/feidewu/article/details/8037848

package com.java.demo;

import java.io.*;
import java.util.*;

public class KeywordIdentifier {
    //java中的关键字存放进数组中
    //注意，统计程序关键字时并不包括此数组中的关键字，因为“int”等字符串无法用正则表达式区分出关键字来
    String KEYWORDS[] = {"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const",
            "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float", "for",
            "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "package",
            "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized",
            "this", "throw", "throws", "transient", "try", "void", "volatile", "while"};
    TreeMap<String, Integer> keycode = new TreeMap<String, Integer>();
    String Keys[];//用于存放正则表达式划分出来的字符串
    String Lineword = null;//用于存放从文件中读进的每一行字符串
    int ChildStrNum;//每一行字符串的子字符串个数
    int num3 = 0;//用于统计关键字的总个数

    void Handle(BufferedReader StringBuff) throws IOException {
        for (int k = 0; k < KEYWORDS.length; k++)//将java数组中的关键字放进集合中
        {
            keycode.put(KEYWORDS[k], new Integer(0));
        }

        while ((Lineword = StringBuff.readLine()) != null) {
            Keys = Lineword.trim().split(" ");//去掉前导空格，根据正则表达式以空格划分字符串
            ChildStrNum = Keys.length;//每一行字符串的子字符串个数
            for (int j = 0; j < ChildStrNum; j++) {
                if (keycode.containsKey(Keys[j])) {
                    num3++;
                    Integer number3 = (Integer) keycode.get(Keys[j]);//获取集合中关键字已有的个数
                    keycode.put(Keys[j], new Integer(number3.intValue() + 1));//关键字个数增1
                }
            }
        }
    }

    void Print()//输出关键字统计信息
    {
        System.out.println("\n该文件关键字个数为：" + num3);
        System.out.println("每个关键字个数为：");
        Iterator iter3 = keycode.keySet().iterator();
        int m = 0;//用作换行
        while (iter3.hasNext()) {
            Object temp3 = iter3.next();//获取迭代器所指向的对象
            if (keycode.get(temp3) > 0) {
                m++;
                System.out.print(temp3.toString() + ":" + keycode.get(temp3) + "  ");
                if (m % 10 == 0)
                    System.out.println();
            }
        }
    }

    public static void main(String[] args) {
        BufferedReader StringBuff = null;
        try {
            StringBuff = new BufferedReader( new FileReader("src/com/java/demo/LinkedList_Practice.java"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        KeywordIdentifier CalculateKeyWords=new KeywordIdentifier();
        try {
            CalculateKeyWords.Handle(StringBuff);//处理函数
        } catch (IOException e) {
            e.printStackTrace();
        }
        CalculateKeyWords.Print();//打印统计信息
        try {
            StringBuff.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

怡人蝶梦

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
1
评论
java上机作业

第一次问题描述: 实现程序,找出一个数组中最大元素的最小下标值(假定数组中元素可以重复)import java.util.Arrays;import java.util.Random;//import java.util.Scanner;public class HomeWork1_1 { public static void main(String[] args){ /* Scanner sc=new Scanner(System.in); int
复制链接

扫一扫