Java学习----基本计算方法的应用

Java学习—-基本计算方法的应用

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++)//i从1循环到100
        {
            sum=sum+i;//累加到sum变量中
        }
        System.out.println("sum="+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)//i从1间隔一个数累加到101
        {
            sum=sum+i;//累加到sum变量中
        }
        System.out.println("sum="+sum);//输出sum的值
    }
}

运行结果为：

C. 编程实现输出10个随机整数，值在0到100之间。

源代码：

public class test3 {
    public static void main(String[] args) {
        int[] a=new int[10];//创建一个包含10个元素的int型数组a
        for(int i=0;i<a.length;i++) {//i从0循环到9
            a[i]=(int)(Math.random()*101);//Math.random()返回一个double类型的0.0-1.0之间的数值，包括0，不包括1，这个数值*101，那范围就是0-101(不包括)了么,强转之后就是整型。
        }
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");//输出数值a中的值
        }
    }
}

运行结果为：

D. 对C步的10个随机整数并行排序。

源代码：

import java.util.Arrays;
public class test4 {
    public static void main(String[] args) {
        int[] a=new int[10];//创建一个包含10个元素的int型数组a
        for(int i=0;i<a.length;i++) {//i从0循环到9
            a[i]=(int)(Math.random()*101);//Math.random()返回一个double类型的0.0-1.0之间的数值，包括0，不包括1，这个数值*101，那范围就是0-101(不包括)了么,强转之后就是整型。
        }
         Arrays.parallelSort(a);//对a中的数进行并行排序
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");//输出数值a中的值
        }
    }   
}

运行结果为：

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);
    }
}

运行结果为：