JAVA学习笔记

3.8

输出保留三位小数的数字

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        float a=input.nextFloat();
        System.out.println(String.format("%.3f",a));//转化为字符，保留三位小数
    }
}

字符菱形

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        char a = input.next().charAt(0);
        /*
        字符类型的两种输入
        String a = input.next();
        char a = input.next().charAt(0);
         */
        System.out.print("  "+a+"\n"+" "+a+a+a+"\n"+a+a+a+a+a+"\n"+" "+a+a+a+"\n"+"  "+a);
    }
}

计算（a+b）*c:

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        int a,b,c,d;//定义全局变量
        Scanner input=new Scanner(System.in);
        a=input.nextInt();
        b=input.nextInt();
        c=input.nextInt();
        d=(a+b)*c;
        System.out.print(d);


    }
}

计算分数的浮点数值

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        double a,b,c;
        Scanner input=new Scanner(System.in);
        a=input.nextInt();
        b=input.nextInt();
        c=a/b;
        System.out.println(String.format("%.9f",c));
    }
}

3.9

数据类型判断：

System.out.println((double)a/b);
        /*
        结果为范围更大的数据类型：double
        System.out.println(1.0a/b);转化为浮点数
         */

java输出默认保留六位小数

System.out.printf("%.xf",s);//保留s实参x位小数

parameter:形参

argument:实参

java取整方法：

/*
Math.ceil();//向上取整

Math.floor();//向下取整

Math.round();//四舍五入

Math.rint();//就近取整
计算结果为double类型
*/

字符串的输入

char s = input.next().charAt(0);
/*
这里输出s的零号下标
tips:(为什么下标大多从零开始？)
偏移量：
a[0]=a+0;
a[1]=a+1;
a[2]=a+2;
*/

or

String s = input.next();

3.14

判断奇偶数

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        System.out.printf(n % 2 == 0 ? "even" : "odd");
        /*
        Java中的三目运算符
1、三目运算符：又称之为三元运算符

2、格式：(关系表达式)?表达式1:表达式2;

3、如果关系表达式的结果为true，运算后的结果是表达式1；

4、如果关系表达式的结果为false，运算后的结果是表达式2
         */
    }
}

3.26

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();//天数
        int sum1=0;
        int sum2=0;
        int sum3=0;
        for(int i=1;i<=n;i++){
            sum1+=input.nextInt();
            sum2+=input.nextInt();
            sum3+=input.nextInt();
        }
        System.out.print(sum1+" "+sum2+" "+sum3+" "+(sum1+sum2+sum3));
    }
}

3.28

Array

for(int element : nums)//单向从头到尾遍历数组

3.29

import java.util.Scanner;
public class Main {
    /**
     *factorial_sum 返回一个整数序列
     *
     * @param n 正整数，代表不大于n的正整数的阶乘的底数
     * @return 非负数,代表阶乘的和
     */
    public int factorial_sum(int n){
        int factorial = 1;//阶乘结果
        int ans = 0;//求和结果
        for(int i=1;i<=n;i++){//阶乘和
            factorial = factorial*i;
            ans = ans+factorial;
        }
        return ans;
    }
    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        System.out.println(test.factorial_sum(n));
    }
}

2023.4.4

字符串

public class Main {
    public static void main(String[] args) {
        String text = "abc";//text指向"abc"或者"a"
        int length = text.length();//长度
        int add1 = text.indexOf("b");//"b"第一次出现的下标
        int add2 = text.lastIndexOf("b");//"b"最后一次出现的下标
        String substring = text.substring(3,6);//输出String子串,左闭右开
        System.out.println(substring);
    }
}

4.11

冒泡排序

key:如果前一个元素比后一个元素大，则交换  

 import java.util.Arrays;
//冒泡排序
public class BubbleSort_01 {
	public static void main(String[] args) {
		int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
		int count=0;//记录比较次数
		for (int i = 0; i < a.length-1; i++) {//排序多少轮
			for (int j = 0; j < a.length-1-i; j++) {//交换多少次
				if (a[j]>a[j+1]) {
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
				count++;
			}
		}
		System.out.println(Arrays.toString(a));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
		System.out.println("一共比较了："+count+"次");//一共比较了：105次
	}
}

 

4.13

A到Z分别是65到90，十六进制是41到5a

a到z分别是97到122，十六进制是61到7a

5.2

import java.util.Scanner;

import static java.lang.Character.isLowerCase;
import static java.lang.Character.isUpperCase;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Main test = new Main();
        String text1 = input.next();
        String text2 = input.next();
        System.out.print(test.bool(text1, text2));
    }
    /**
     * bool 返回字符串移位判断子串结果
     *
     * @param text1,text2 字符串，代表输入的字符串
     * @return 布尔数，是否为字符串移位判断子串
     *
     */
    public boolean bool(String text1, String text2){
        String ans="";
        char[] t1=text1.toCharArray();
        char[] t2=text2.toCharArray();
        int n1 = text1.length();
        int n2 = text2.length();
       if(n1>=n2){
           //循环位移
           for(int i=0;i<n1;i++){
               char temp =t1[0];
               for(int j=0;j<n1-1;j++){
                   t1[j]=t1[j+1];
               }
               t1[n1-1]=temp;
               //判断子串
               if(new String(t1).contains(text2)){
                   return true;
               }
           }
       }else if(n2>n1){
           //循环位移
           for(int i=0;i<n2;i++){
               char temp =t2[0];
               for(int j=0;j<n2-1;j++){
                   t2[j]=t2[j+1];
               }
               t2[n2-1]=temp;
               //判断子串
               if(new String(t2).contains(text1)){
                   return true;
               }
           }
       }
       return false;
    }
}

import java.util.Scanner;

import static java.lang.Character.isLowerCase;
import static java.lang.Character.isUpperCase;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Main test = new Main();
        String word = input.next();
        System.out.print(test.delete(word));
    }
    /**
     * delete 返回字符串去除er or ly or ing 的结果
     *
     * @param word 字符串，代表输入的字符串
     * @return 字符串去除er or ly or ing 的结果
     *
     */
    public String delete(String word){
        String ans="";//储存后缀被删除后的单词
        int l =word.length();
        if(word.endsWith("er")||word.endsWith("ly")){//以er或ing结尾
            ans = word.substring(0,l-2);
        } else if (word.endsWith("ing")) {
            ans=word.substring(0,l-3);
        } else {
            ans = word;
        }
        return ans;
    }
}

5.31

import java.util.Scanner;

public class Main {
    /**
     * powerOfTwo计算2的指定次方
     *
     * @param n 正整数，代表指定的次方
     * @return 整型数组，代表2的n次方
     */
    public int[] powerOfTwo(int n) {
        int[] ans = new int[1000]; // ans数组用于保存2的n次方的结果

        // 初始化数组，将第一位设置为1
        ans[0] = 1;

        // 循环计算2的n次方
        for (int i = 0; i < n; i++) {
            int carry = 0; // 进位标志，初始化为0
            for (int j = 0; j < ans.length; j++) {
                int tmp = ans[j] * 2 + carry; // 计算当前位的结果
                if (tmp > 9) { // 如果乘积超过10，则需要进位
                    carry = 1;
                    tmp = tmp % 10;
                } else {
                    carry = 0;
                }
                ans[j] = tmp; // 将结果存储到当前位置
            }
        }

        return ans;
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int[] ans = test.powerOfTwo(n);
        boolean leadingZero = true; // 标记是否已经遇到第一个非0数字
        for (int i = ans.length - 1; i >= 0; i--) { // 从高位向低位遍历数组
            if (ans[i] != 0) {
                leadingZero = false; // 遇到第一个非0数字，标记位置改为false
            }
            if (!leadingZero) { // 如果leadingZero为false，说明前面已经有非零数字了，直接输出当前位的值
                System.out.print(ans[i]); // 输出当前位的值
            }
        }
    }
}

6.20

import java.util.Scanner;
public class Main {
    /**
     *nums 返回一个整数序列
     *
     * @return 非负数,血压连续正常的最长小时数
     */
    public int nums(){
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();//数据组数
        int ans = 0;
        int res = 0;//res作用就是帮助ans连续记录
        for(int i =1;i<=n;i++){
            int shrink = input.nextInt();
            int relax = input.nextInt();
            if((90<=shrink&&shrink<=140)&&(60<=relax&&relax<=90)){
                res = res+1;
                if(res>ans){
                    ans = res;
                }

            }else{
                res = 0;
            }
        }
        return ans;
    }
    public static void main(String[] args) {
        Main test = new Main();
        System.out.println(test.nums());
    }
}

数组逆序交换：

import java.util.Scanner;
public class Main {
    /**
     * reverse 返回一个整数序列
     *
     * @param n    正整数，代表数组元素个数
     * @param nums 整型数组，存储整数序列
     * @return 返回一个逆序的整型数组
     */
    public void reverse(int n, int[] nums) {
        int t;
        for (int i = 0; i < n / 2; i++) {
            t = nums[i];
            nums[i]=nums[n-i-1];//(i)+(n-i-1)=1;
            nums[n-i-1]=t;
        }
    }
    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();//元素个数
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = input.nextInt();
        }
        test.reverse(n, nums);
        for (int i = 0; i < n; i++) {
            System.out.print(nums[i] + " ");
        }
    }
}

骑士与金币

import java.util.Scanner;
public class Main {
    /**
     * salary 返回骑士n天能得到的金币
     *
     * @param n 整数，骑士拿金币的天数
     * @return 返回骑士能拿金币的总数
     */
    public int salary(int n) {
        int ans= 0;//金币数
        int i;//第i行
        for(i=1;n-i>=0;i++){
            ans=ans+i*i;
            n=n-i;//天数也要变化
        }
        if(i>n){
            ans=ans+n*i;
        }
        return ans;
    }
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Main test = new Main();
        int n = input.nextInt();//天数
        System.out.print(test.salary(n));
    }
}

与最大数之外的数相加求和

key:foreach循环

import java.util.Scanner;
public class Main {
    /**
     * Sum返回一个整数序列
     * @param N 为接下来数的个数
     * @param a 整数，N个整数
     * @return N个数中除去最大数其余数字之和
     */
    public int Sum(int N, int[] a) {
        int max=a[0];
        int ans=0;
        for (int i = 0; i < N; i++) {
            if(a[i]>max){
                max=a[i];}
        }
        for(int i:a){//foreach循环
            ans=(i==max?ans:ans+i);
        }
        return ans;
    }
    public static void main(String[] args) {
        Main main = new Main();
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            a[i]=input.nextInt();
        }
        int result = main.Sum(N, a);
        System.out.println(result);
    }
}

奇数单增序列

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    /**
     * bubbleSort通过冒泡排序将序列元素排成顺序
     *
     * @param nums 整型数组，存储待排序的序列元素
     */
    public void bubbleSort(int[] nums) {
        int n = nums.length;
        int t; // 交换暂存量
        /* 对nums数组采用冒泡排序，排成顺序 */
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n - i-1; j++) {
                if (nums[j] > nums[j + 1]) { // 如果当前数大于后一个数
                    t = nums[j]; // 则将当前数和后一个数交换
                    nums[j] = nums[j + 1];
                    nums[j + 1] = t;
                }
            }
        }
    }

    /**
     * oddElements返回序列中所有的奇数元素
     *
     * @param nums 整型数组，存储序列元素
     * @return 数组，存储nums中所有的奇数元素
     */
    public int[] oddElements(int[] nums) {
        int n = nums.length;
        int k = 0; // nums中奇数元素的个数
        int[] ans = new int[n]; // 返回结果
        /* 通过foreach循环遍历nums数组每个元素 */
        for (int i : nums) {
            if (i % 2 != 0) { // 如果当前元素是奇数
                ans[k] = i; // 则将当前元素推入ans中
                k++; // 奇数元素的个数增加1个
            }
        }
        return Arrays.copyOfRange(ans,0,k); // 返回ans前k个元素
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        int[] nums = new int[N];
        for (int i = 0; i < N; i++) {
            nums[i] = input.nextInt();
        }
        int[] ans = test.oddElements(nums);
        test.bubbleSort(ans);
        System.out.print(ans[0]); // 首先输出第1个奇数
        /* 从第2个奇数开始，先输出一个逗号，再输出奇数 */
        for (int i = 1; i < ans.length; i++) {
            System.out.print("," + ans[i]);
        }
    }
}

字符串常用的语法规则： 

char[] chars = text.toCharArray();//将字符串变为字符数组
String tra = String.valueOf(chars);//将 char 数组 data 转换成字符串 

public class Main {
    public static void main(String[] args) {
        String text = "abc";//text指向"abc"或者"a"
        int length = text.length();//长度
        int add1 = text.indexOf("b");//"b"第一次出现的下标
        int add2 = text.lastIndexOf("b");//"b"最后一次出现的下标
        String substring = text.substring(3,6);//输出String子串,左闭右开
        System.out.println(substring);
    }
}

String s1 = input.next();
String s3 = input.nextLine();
/*
在java中，next()方法是不接收空格的
而在nextLine()可以接收空格
*/     

 判断ans[i]是否全为大写或者小写

isUpperCase(ans[i]);//判断大写
isLowerCase(ans[i]);//判断小写
toUpperCase(ans[i]);//变为大写
toLowerCase(ans[i]);//变为小写

判断两个由大小写字母和空格组成的字符串在忽略大小写，且忽略空格后是否相等

import java.util.Scanner;

public class Main {
    /**
     * isEqual判断两个字符串在忽略大小写且忽略空格后是否相等
     *
     * @param one 待比较的字符串
     * @param two 待比较的字符串
     * @return true，当且仅当one和two在忽略大小写且忽略空格后相等，否则false
     */
    public boolean isEqual(String one, String two) {
        one = one.replace(" ", ""); // 移除one中空格
        two = two.replace(" ", ""); // 移除two中空格
        // one和two在忽略大小写后相等，返回true，否则false
        return one.equalsIgnoreCase(two);
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        String one = input.nextLine();
        String two = input.nextLine();
        System.out.print(test.isEqual(one, two) ? "YES" : "NO");
    }
}

表达式 one.compareTo(two) < 0 用于比较字符串 one 和 two 的大小关系。

如果 one 字符串在字典顺序上小于 two 字符串，即 one 排在 two 前面，那么该表达式的结果为 true。否则，如果 one 大于等于 two，结果为 false。

compareTo() 方法用于对字符串按照字典顺序进行比较。如果它返回一个负数，表示字符串 one 在字典顺序上小于字符串 two；如果返回零，表示两个字符串相等；如果返回一个正数，表示字符串 one 在字典顺序上大于字符串 two。

num1.subtract(num2)//减法
BigInteger num1 = new BigInteger(numStr1);