java基本算术训练

  • 编程实现1+2+3+、、、+100
  • 编程实现1+3+5+7+、、、+101
  • 编程实现输出十个随机整数，值在0-100之间
  • 对以上生成的十个随机整数进行排序
  • 设有两字符串A、B构成的集合，字符串内容值为以下所示：
  • 程序运行截图
  • 全部的java代码


编程实现1+2+3+、、、+100

废话不多说直接上代码，这里直接展示代码实现部分和代码运行结果。

//创建输出函数快捷键sout
int sum1 = 0, sum2 = 0;
//编程实现1+2+3+...+100
for (int i =1; i <= 100; i++) {
    sum1 += i;
}
System.out.println("\nthe Sum of nature numbers within 100 is :" + sum1);

编程实现1+3+5+7+、、、+101

//编程实现1+3+5+7+9+...+101
int c = 1;//c用来存储奇数
for (int i = 1; i <= 50; i++) {
    sum2 += c;
    c += 2;
}
System.out.println("\nthe Sum of odd numbers within 101 is :" + sum2);

编程实现输出十个随机整数，值在0-100之间

//编程实现输出10个随机整数，值在0-100之间
Random r = new Random(30);//创建一个新的伪随机数生成器
//定义一个数组来承接生成的随机数
int[] ran = new int[10];
System.out.println("\n生成的随机数为：");
for (int i = 0; i < 10; i++) {
    int t1 = r.nextInt(100);
    ran[i] = t1;
    System.out.printf(t1 + "   ");
}

对以上生成的十个随机整数进行排序

在此处进行排序我使用了两种方式分别实现了对于十个数字的排序功能，分别为选择法和冒泡排序法。两种排序方式都可以，故我使用这两种方式一个实现正序排列一个实现了倒序排列。在具体应用中两种都可以。

//创建方法使用快捷键 Alt+Insert
//方法一，选择法，第一次循环都和第一个比较，把最小的放在最前边
public static int[] sort(int[] a) {
    int[] b=new int[10];
    for (int i = 0; i < 10; i++) {
        for (int j = i+1; j <10; j++) {
            if(a[i]>a[j]){
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
    }
    return a;
}
//方法二：冒泡排序法，相邻两个进行比较，将最大的放到最后边
public static int[] sort1(int[] a) {
    for(int i=0;i<10;i++){
        for(int j=0;j<10-i-1;j++){
            if(a[j]>a[j+1]){
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
    return a;
}

设有两字符串A、B构成的集合，字符串内容值为以下所示：

A:{a,b,c,d,e,f,g,in,off,about,get}
B:{f,g,a,come,get,go}

试求出

  1. 求出集合A、B的交集；
  2. 只在集合A中出现的字符串集合；
  3. 集合A、B的并集。

以下则分别实现三个功能，首先实现要求1，求出AB集合的交集

//返回集合A和集合B交集
public static String[] samestr(String[] a,String[] b) {
    String[] aa=new String[20];
    int k=0;
    for (int i=0;i<a.length;i++){
        for(int j=0;j<b.length;j++){
            if(a[i]==b[j]){
                aa[k]=a[i];
                k++;
                break;
            }
        }
    }
    return aa;
}

接下来实现要求2，求出只在A中出现的字符串集合：

//返回字符串a独有的集合
public static ArrayList diffstr(String[] a, String[] b) {
    ArrayList aa=new ArrayList();//用来存储字符串a
    ArrayList bb=new ArrayList();//用来存储字符串b
    for (int i = 0; i < a.length; i++) {
        aa.add(a[i]);
    }
    for (int i = 0; i < b.length; i++) {
        bb.add(b[i]);
    }
    //移除aa中包含的bb
    aa.removeAll(bb);
    return aa;
}

最后再来实现要求3，求A、B集合的并集

//返回AB集合并集
public static ArrayList gatherstr(String[] a,String[] b) {
    ArrayList aa=new ArrayList();
    for (int i = 0; i < a.length; i++) {
        aa.add(a[i]);
    }
    for (int i = 0; i < b.length; i++) {
        aa.add(b[i]);
    }
    return aa;
}

程序运行截图

以下我展示出程序运行后的结果：

Java随机生成复杂密码 java随机生成算术题_基本运算

全部的java代码

最后我还提供出此次练习的全部java源码，供大家一起学习讨论。代码中有什么不足之处，欢迎大家斧正。

package main.java.demo;

import java.util.ArrayList;
import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 * User: kingback
 * Author:king@王延凯
 * Date: 2019/4/6
 * Time: 20:39
 * Description: No Description
 */
public class HelloWorld {
    //创建main函数快捷键psvm
    public static void main(String[] args) {

        //创建输出函数快捷键sout
        int sum1 = 0, sum2 = 0;
        //编程实现1+2+3+...+100
        for (int i =1; i <= 100; i++) {
            sum1 += i;
        }
        System.out.println("\nthe Sum of nature numbers within 100 is :" + sum1);
        //编程实现1+3+5+7+9+...+101
        int c = 1;//c用来存储奇数
        for (int i = 1; i <= 50; i++) {
            sum2 += c;
            c += 2;
        }
        System.out.println("\nthe Sum of odd numbers within 101 is :" + sum2);

        //编程实现输出10个随机整数，值在0-100之间
        Random r = new Random(30);//创建一个新的伪随机数生成器
        //定义一个数组来承接生成的随机数
        int[] ran = new int[10];
        System.out.println("\n生成的随机数为：");
        for (int i = 0; i < 10; i++) {
            int t1 = r.nextInt(100);
            ran[i] = t1;
            System.out.printf(t1 + "   ");
        }

        int[] aa = new int[10];
        aa = sort(ran);
        System.out.println("\n\n排序后的结果为：");
        for (int i = 0; i < 10; i++) {
            System.out.print(aa[i] + "   ");
        }
        //多行注释ctrl+shift+/
       /* for(int i=0;i<10;i++){
            System.out.println(ran[i]);
        }*/

        //设有两字符串构成的集合，字符串内容如下所示
        String[] str = {"a", "b", "c", "d", "e", "f", "g", "in", "off", "about", "get"};
        String[] str1 = {"f", "g", "a", "come", "get", "go"};
        String[] togather = new String[20];
        String[] diff = new String[20];

        //要求找出两个集合的交集,并集
        togather = samestr(str, str1);
        //输出AB的交集
        System.out.print("\n\nAB的交集: ");
        for (int i = 0; i < togather.length; i++) {
            if (togather[i] != null) {
                System.out.print(togather[i] + "   ");
            }
        }
        //输出只在A中出现的字符串
        System.out.println("\n\n只在A中出现的集合： ");
        ArrayList aaa = new ArrayList();
        aaa = diffstr(str, str1);
        for (int i = 0; i < aaa.size(); i++) {
            System.out.printf(" " + aaa.get(i) + " ");
        }
        //输出AB集合并集
        ArrayList bbb=gatherstr(str,str1);
        System.out.println("\n\nAB的并集为： ");
        for (int i = 0; i < bbb.size(); i++) {
            System.out.print(" "+bbb.get(i)+" ");
        }
    }
    //创建方法使用快捷键 Alt+Insert
    //方法一，选择法，第一次循环都和第一个比较，把最小的放在最前边
    public static int[] sort(int[] a) {
        int[] b=new int[10];
        for (int i = 0; i < 10; i++) {
            for (int j = i+1; j <10; j++) {
                if(a[i]>a[j]){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
        return a;
    }
    //方法二：冒泡排序法，相邻两个进行比较，将最大的放到最后边
    public static int[] sort1(int[] a) {
        for(int i=0;i<10;i++){
            for(int j=0;j<10-i-1;j++){
                if(a[j]>a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }
    //返回集合A和集合B交集
    public static String[] samestr(String[] a,String[] b) {
        String[] aa=new String[20];
        int k=0;
        for (int i=0;i<a.length;i++){
            for(int j=0;j<b.length;j++){
                if(a[i]==b[j]){
                    aa[k]=a[i];
                    k++;
                    break;
                }
            }
        }
        return aa;
    }
    //返回字符串a独有的集合
    public static ArrayList diffstr(String[] a, String[] b) {
        ArrayList aa=new ArrayList();//用来存储字符串a
        ArrayList bb=new ArrayList();//用来存储字符串b
        for (int i = 0; i < a.length; i++) {
            aa.add(a[i]);
        }
        for (int i = 0; i < b.length; i++) {
            bb.add(b[i]);
        }
        //移除aa中包含的bb
        aa.removeAll(bb);
        return aa;
    }
    //返回AB集合并集
    public static ArrayList gatherstr(String[] a,String[] b) {
        ArrayList aa=new ArrayList();
        for (int i = 0; i < a.length; i++) {
            aa.add(a[i]);
        }
        for (int i = 0; i < b.length; i++) {
            aa.add(b[i]);
        }
        return aa;
    }