第二次实验及动手动脑

//何伟豪     2018/10/14
//实现任意两个数之间的素数输出

package 素数输出;

import java.util.*;


public class 素数输出 {
    public static void main(String [] arge) {
        Scanner in = new Scanner(System.in);
        int number1,number2;   //输入的两个数
        int sum5=1;            //判断是否该换行的变量
        int opt=0;             //记录是否为素数的变量
        int n;                 //动态数组
        int m=0;
        System.out.println("请输入两个大于等于三的整数");
        number1 = in.nextInt();       //输入前限
        number2 = in.nextInt();       //输入后限
        n=number2-number1;          //给动态数组中的n赋值
        int[] daxiao=new int[n];
        System.out.println(number1 + "~" + number2 + "间的所有素数如下:");
        //判断两数间的每个数是否为素数的循环
        for(int i=number1;i<=number2;i++) {
            double ii=Math.sqrt(i);
            //从2开始判断是否出现除不尽的数
            for(int o=2;o<=ii+1;) {
                //如果除尽的话
                if(i%o==0) {
                    o=number2;
                    opt=0;
                }
                //除不尽的话
                else {
                    o++;
                    opt=1;
                }
            }
            if(opt==1) {
                if(sum5<5) {
                    sum5++;
                    System.out.print(i + " ");
                    daxiao[m]=i;
                    m++;
                }else {
                    sum5=1;
                    System.out.println(i + " ");
                    daxiao[m]=i;
                    m++;
                }
            }
            
        }
        System.out.println();
        if(m<10) {
            System.out.println("你所输入的两数之间素数不够十个！");
        }else {
            System.out.println("最小的十个素数如下：");
            for(int qshi=0;qshi<10;qshi++) {
                System.out.print(daxiao[qshi] + " ");
            }
            System.out.println();
            System.out.println("最大的十个素数如下：");
            for(int hshi=m-1;hshi>m-11;hshi--) {
                System.out.print(daxiao[hshi] + " ");
            }
        }
        in.close();
    }
}



//何伟豪   2018/10/14
//判断某个字串是否是回文

package 字符串回文;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class 字符串回文 {

    public static void main(String[] args)throws Exception {
          String shuru ="";
          BufferedReader zfc = new BufferedReader(new InputStreamReader(System.in),256);
          System.out.println("请输入字符串:");
          shuru = zfc.readLine();
          System.out.println("检查结果： " + huiwen(shuru,0,shuru.length()-1));
    }
         
    public static boolean huiwen(String s,int start,int end){
          if(start == end) 
              return true;
          if(start > end){
              System.out.println("您没有输入任何字符串！");
              return false;
          }
          if(s.charAt(start) == s.charAt(end)){
              return huiwen(s,start+1,end-1);
          }
          else{
              return false;
          }
    }
}




//何伟豪      2018/10/14
//查相同的字母有多少个
package 论文查重;
import java.io.*;
import java.util.*;

public class 查重 {
    public static void main(String[] args){
        demo(new File("C:\\Users\\Lenovo\\Desktop\\JAVA\\临时文件\\论文查重\\论文查重\\作文.txt"));
    }
    public static void demo(File file){
        BufferedReader bfr = null;   //定义字符读取(缓冲)流
        try{
            bfr = new BufferedReader(new FileReader(file));//给该流赋值
            String value = null; //定义一个临时接收文件中的字符串变量
            String newValue = "";    //接收文件中所有字符串的变量
            while((value = bfr.readLine())!=null){    //开始读取文件中的字符
                newValue = newValue+value;    //存入newValue变量中
            }
            char[] ch = newValue.toCharArray();//把newValue变成字符数组
            TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>(Collections.reverseOrder());/*定义一个TreeMap(因为TreeMap是有序的，存入的键值都有自然比较顺序功能,默认的是从小到大顺序，所有这里传了一个反转的比较器)，键对应字符，值对应字符出现的次数**/
            for(int x = 0;x<ch.length;x++){   //遍历ch  将ch中所有的字符存入一个Map集合中(TreeSet)，键对应字符，值对应字符出现的次数
                char c = ch[x];
                if(tm.containsKey(c)){  //如果TreeMap(tm)中有该键，则取出该键中的值，也就是出现的次数
                    int conut = tm.get(c);
                    tm.put(c,conut+1);  //存入把新值存入tm集合中，如果键相同的话， 新键会替换老键，值也随着变化了
                }
                else{
                    tm.put(c, 1);  //如果没有出现该键就说明是第一次出现，然后就存入1次
                }
            }
            //下面的是取出TreeMap(tm)中的键和值
            Set<Map.Entry<Character, Integer>> set = tm.entrySet();
            Iterator<Map.Entry<Character, Integer>> iter = set.iterator();
            while(iter.hasNext()){
                Map.Entry<Character, Integer> map = iter.next();
                char k = map.getKey();
                int v = map.getValue();
                System.out.print(k+"("+v+")  ");
            }
        }
        catch(IOException e){
            System.out.println("文件读取错误");
        }
        finally{
            try{
                if(bfr!=null)
                    bfr.close();
            }
            catch(IOException e){
                System.out.println("文件关闭错误");
            }
        }
    }
}





动手动脑：
// MethodOverload.java
// Using overloaded methods

public class MethodOverload {

    public static void main(String[] args) {
        System.out.println("The square of integer 7 is " + square(7));
        System.out.println("\nThe square of double 7.5 is " + square(7.5));
    }

    public static int square(int x) {
        return x * x;
    }

    public static double square(double y) {
        return y * y;
    }
}

转载于:https://www.cnblogs.com/hwh000/p/9787066.html