JAVA基本计算应用任务（一）

任务A：1+2+3+…+100

源代码：

public class test1 {
    public static void main(String[] args) {
        int sum=0;//存放累加的数
        for(int i=1;i<=100;i++){//从1循环到100
            sum+=i;//累加到sum变量中
        }
        System.out.println(sum);//输出sum
    }
}

运行结果：

任务B: 1+3+5+7+9+…+101

源代码：

public class test2 {
    public static void main(String[] args) {
        int sum = 0;//存放累加的数
        for (int i = 1; i <= 101; i=i+2) {//从1循环到100
            sum +=i;//累加到sum变量中
        }
                  System.out.println(sum);
    }
}

运行结果：

任务C：实现输出10个随机整数，值在0到100之间

源代码：

public class test3 {
 public static void main(String[] args) {
  int[] a=new int[10];//定义一个大小为10的数组
  int i;
  for(i=0;i<a.length;i++){//（i<10)
   a[i]=(int)(Math.random()*101); 
  }//随机生成大小在1~100的整数
  for(i=0;i<a.length;i++){
   System.out.print(a[i]+" "); //输出数组
  } 
 }
}

运行结果：

任务D：输出10个随机整数，值在0到100之间，并进行排序

源代码：

public class test4 {

public static void main(String[] args){

int a[] = new int[10];//定义一个大小为10的数组

int temp;//定义一个变量temp

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

a[i] = (int)(Math.random()*101);

}//随机生成大小在1~100的整数

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

for(int j = i+1; j < 10; j++){//for循环嵌套

if(a[i] > a[j]){

temp = a[i];//逐个比较

a[i] = a[j];

a[j] = temp;

}

}

}

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

System.out.print(a[i] + "   ");//输出比较后的数组

}

}

}

运行结果：

任务E：

设有两字串构成的集合，字符串内容值为A:{a,b,c,d,e,f,g,in,off,about,get}， B:{f,g,a,come,get,go}

求出：（1）AB集合的交集。（2）只在A集中出现的字串集合。 （3）AB集合的并集。

源代码：

import java.awt.List;
import java.security.KeyStore.Entry;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;

public class test5 {
    public static void main(String[] args) {
        String[] A={"a","b","c","d","e","f","g","in","off","about","get"};//创建一个String数组A，然后赋值
        String[] B={"f","g","a","come","get","go"};//创建一个String数组B，然后赋值

        //交集
        String[] result_insect = intersect(A, B);//调用交集函数
        System.out.println("交集的结果为：");
        for (int i=0;i< result_insect.length;i++) 
        {   
             String str= result_insect[i];
              System.out.print(str+" ");     
        }  

        //只有A中有的字串
        String[] result_only = only(A,B);//调用only方法
        System.out.println();  
        System.out.println("只在A集中出现的字串为:");
        for(int i=0;i<result_only.length;i++) {
            if(result_only[i] != null) {
                System.out.print(result_only[i]+" ");
            }
        }

        //并集
        String[] result_union = union(A, B); //调用并集函数
        System.out.println();  
        System.out.println("并集的结果为：");
        for (int i=0;i<result_union.length;i++) 
        {   
             String str=result_union[i];
              System.out.print(str+" ");     
        }   
    }

    //求交集函数
     public static String[] intersect(String[] A, String[] B) {   
         Map<String, Boolean> map = new HashMap<String, Boolean>();   
         LinkedList<String> list = new LinkedList<String>();
         for (int i=0;i<A.length;i++) 
         {   
             String str=A[i];
             if (!map.containsKey(str)) {   
                 map.put(str, Boolean.FALSE);   
             } 
         } 
         for (int i=0;i<B.length;i++) 
         {   
             String str=B[i];
             if (map.containsKey(str)) {   
                 map.put(str, Boolean.TRUE);   
             } 

         }   
         for (java.util.Map.Entry<String, Boolean> e : map.entrySet()) {   
                  if (e.getValue().equals(Boolean.TRUE)) {   
                      list.add(e.getKey());   
                  }   
              }   

              String[] result = {};   
              return list.toArray(result);   
          }
    //调用only方法  
     public static String[] only(String[] A,String[] B) {
         String[] result = new String[10];
         int a = 0;
         for(int i=0;i<A.length;i++) {
             java.util.List<String> list = Arrays.asList(B);
             if(!list.contains(A[i])) {
                 result[a] = A[i];
                 a++;
             }
         }
         return result;
     }

    //求并集函数
    private static String[] union(String[] A, String[] B) {
        Set<String> set = new HashSet<String>();   
                 for (int i=0;i<A.length;i++) 
                 {   
                     String str=A[i];
                      set.add(str);   
                 }   
                 for (int i=0;i<B.length;i++) 
                 {   
                     String str=B[i];
                      set.add(str);   
                 }    
                 String[] result = {};   
                  return set.toArray(result);
    }
}

运行结果: