Java基础API

目录：

1.Scanner类
使用步骤：

1、导包：import

java.util.Scanner;

2、创建(System.in代表从键盘输入)

Scanner sc = new Scanner(System.in);

3、使用

int num = sc.nextInt();
String str = sc.next();

练习：
1、键盘输入两个int数字，并且求和

import java.util.Scanner;

public class Scanner_test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入第一个数字：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数字：");
        int b = sc.nextInt();

        int result = a + b;
        System.out.println("结果是："+result);
    }
}

2、键盘输入3个int数字，求出其中的最大值

import java.util.Scanner;

//键盘输入3个int数字，求出其中的最大值
public class Scanner_Max_Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入第一个数字:");
        int a = sc.nextInt();
        System.out.println("请输入第二个数字:");
        int b = sc.nextInt();
        System.out.println("请输入第三个数字:");
        int c = sc.nextInt();

        int temp = a > b ? a : b;
        int max = temp > c ? temp : c;
        System.out.println("最大值是："+max);
    }
}
2.匿名对象

没有名字的类叫做匿名对象。
匿名对象只能使用唯一的一次，下次使用不得不再创建一个新对象。

使用建议：
如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象。

public class Person {
    String name;

    public void showName(){
        System.out.println("我叫"+name);
    }
}

public class Annoymous_test {
    public static void main(String[] args) {
        //左边的one就是对象的名字
        Person one = new Person();
        one.name = "Java";
        one.showName(); //我叫java
        System.out.println("=====================");

        //匿名对象
        new Person().name = "java2";
        new Person().showName(); //我叫null
    }
}

匿名对象作参数和返回值

import java.util.Scanner;

public class Annoumous_test1 {
    public static void main(String[] args) {
        //普通使用方式
//        Scanner sc = new Scanner(System.in);
//        int num = sc.nextInt();

        //使用匿名对象方式
//        int num = new Scanner(System.in).nextInt();
//        System.out.println("输入的是"+num);

        //使用一般写法传入参数
//        Scanner sc = new Scanner(System.in);
//        methodParam(sc);

        //使用匿名对象来进行传参
        //methodParam(new Scanner(System.in));
        
        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("输入的是："+num);
    }

    public static void methodParam(Scanner sc){
        int num = sc.nextInt();
        System.out.println("输入的是："+num);
    }

    public static Scanner methodReturn(){
        return new Scanner(System.in);
    }
}
3.Random类
1、导包 
import java.util.Random

2、创建

Random r = new Random();

3、使用
范围为左闭右开区间

import java.util.Random;

public class Random_Test {
    public static void main(String[] args) {
        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            int num = r.nextInt(10);//范围实际上为0-9
            System.out.println(num);
        }
    }
}

练习：
1、根据int变量n的值，来获取随机数字，范围是[1, n],可以取到1也可以取到n。

import java.util.Random;

public class Demo02_Random {
    public static void main(String[] args) {
        int n = 5;
        Random r = new Random();
        //本来范围是[0, n),现在为[0, n]
        for (int i = 0; i < 100; i++) {
            int result = r.nextInt(n) + 1;
            System.out.println(result);
        }
    }
}

2、猜数字游戏

import java.util.Random;
import java.util.Scanner;

//猜数字游戏
public class demo03_RandomGame {
    public static void main(String[] args) {
        Random r = new Random();
        int RandomNum = r.nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);

        while(true){
            System.out.println("输入你猜的数字：");
            int guessNum = sc.nextInt();

            if(guessNum > RandomNum){
                System.out.println("猜大了，请重试！");
            }else if(guessNum < RandomNum){
                System.out.println("猜小了，请重试！");
            }else{
                System.out.println("恭喜你，猜中了！");
                break;
            }
        }
        System.out.println("游戏结束");
    }
}
4.ArrayList集合
1、定义一个数组，用来存储3个Person对象 数组有一个缺点，一旦创建，程序运行期间长度不可以发生改变。 
public class Demo01_Array {
    public static void main(String[] args) {
        //创建一个长度为3的数组，里面用来存放Person类型的对象
        Person[] array = new Person[3];

        Person one = new Person("java1",10);
        Person two = new Person("java2",20);
        Person three = new Person("java3",30);

        //将one中的地址值赋值到数组的0号元素位置
        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]);//地址值
        System.out.println(array[1]);
        System.out.println(array[2]);

        System.out.println(array[1].getName()); //java2
    }
}

数组的长度不可以发生改变，但是ArrayList的长度可以随意发生改变的。
对于ArrayList来说，有一个尖括号代表泛型。
泛型，也就是装在集合当中的所有元素，全部是统一的类型。
注意：泛型只能是引用类型，不能是基本类型。

注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的是空括号：[]

import java.util.ArrayList;

public class Demo02_ArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]
        list.add("java1");
        System.out.println(list);
    }
}

ArrayList当中常用的方法

public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
备注：对于ArrayList集合来说，add添加动作一定是成功的。但对于其他集合来说，add添加动作不一定成功。

public E get(int index):从集合中获取元素，参数是索引编号，返回值就是对应的位置的元素

public E remove(int index):从集合当中删除元素，参数是索引编号，返回值就是被删除的元素

public int size():获取集合长度，返回值是集合中包含的元素个数。

import java.util.ArrayList;

public class Demo03_ArrayList_method {
    public static void main(String[] args) {
//        ArrayList<String> list = new ArrayList<>();
//        boolean success = list.add("java1");
//        System.out.println(success);
//        int num = list.size();
//        System.out.println(num);
//        String s = list.get(0);
//        System.out.println(s);
//        list.remove(0);
//        System.out.println(list);

        ArrayList<String> list  = new ArrayList<>();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        list.add("java4");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

如果希望向集合ArrayList当中存储基本数据类型，必须使用基本类型对应的“包装类”

基本类型包装类（引用类型，包装类都位于java.lang包下）
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

从JDK1.5+开始，支持自动装箱、自动拆箱
自动装箱：基本类型->包装类型
自动拆箱：包装类型->基本类型
练习：
1、生成6个1-33之间的随机整数，添加到集合，并遍历结合

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

public class Demo04_ArrayLIstRandom {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();

        for (int i = 0; i < 6; i++) {
            int num = r.nextInt(33)+1;
            list.add(num);
        }
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

2、自定义4个学生对象，添加到集合，并遍历

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

import java.util.ArrayList;

public class Demo05_ArrayListStudent {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();

        Student one = new Student("java1", 10);
        Student two = new Student("java2", 20);
        Student three = new Student("java3", 30);
        Student four = new Student("java4", 40);

        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);

        //遍历
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println("姓名：" + stu.getName() + "  年龄："+ stu.getAge());
        }
    }
}

3、定义以指定格式打印集合的方法（ArrayList类型作为参数），使用{}括起集合，使用@分隔每个元素，格式参照（元素@元素@元素）

import java.util.ArrayList;

public class Demo06_ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        list.add("java4");
//        System.out.println(list);
        printArrayList(list);
    }

    public static void printArrayList(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i);

            if(i != list.size()-1){
                System.out.print(name + "@");
            }else{
                System.out.println(name + "}");
            }
        }
    }
}

4、用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。
要求使用自定义方法来实现筛选。

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

public class Demo07_ArrayListReturn {
    public static void main(String[] args) {
        ArrayList<Integer> bigList  = new ArrayList<>();
        Random r = new Random();

        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;
            bigList.add(num);
        }

        ArrayList<Integer> SmallList = getSmallList(bigList);
        
        System.out.println("偶数总共有" + SmallList.size() + "个");
        for (int i = 0; i < SmallList.size(); i++) {
            System.out.println(SmallList.get(i));
        }
    }

    //这个方法，接受大集合参数，返回小集合结果
    public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {
        //创建一个小集合装偶数结果
        ArrayList<Integer> smallList = new ArrayList<>();
        for (int i = 0; i < bigList.size(); i++) {
            int num = bigList.get(i);
            if (num % 2 == 0) {
                smallList.add(num);
            }
        }
        return smallList;
    }
}
5.String类
java.lang.String类代表字符串 API当中说，Java程序中所有双引号的字符串，都是String类的对象。（就算没有new，也照样是）

字符串的特点：

  1. 字符串的内容永不可变。【重点】
  2. 正是因为字符串不可改变，所以字符串是可以共享使用的。
  3. 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式：

三种构造方法：

  1. public String()：创建一个空白字符串，不含有任何内容。
  2. public String(char[] array)：根据字符数组的内容，来创建对应的字符串
  3. public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。

一种直接创建：
String str = “Hello”;//右边直接用双引号

注意事项：
直接写上双引号，就是字符串对象。

public class Demo01_String {
    public static void main(String[] args) {
        //使用空参构造
        String str1 = new String();
        System.out.println("第1个字符串：" + str1);//

        //使用字符数组来创建
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("第2个字符串：" + str2);//ABC

        //使用字节数组来创建
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("第3个字符串：" + str3);//abc

        //直接创建
        String str4 = "Hello";
        System.out.println("第4个字符串：" + str4);//hello
    }
}

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中

对于基本类型来说：==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。

==是进行对象的地址值比较，如果需要字符串内容比较，可以使用两个方法：

public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false。

注意事项：

  1. 任何对象都能用Object进行接收。
  2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
  3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。推荐“abc”equals(str)

public boolean equalsIgnorecase(String str)：忽略大小写，进行内容比较。

public class Demo03_StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
        String str3 = new String(charArray);

        System.out.println(str1.equals(str2));//true
        System.out.println(str2.equals(str3));//true
        System.out.println(str3.equals("Hello"));//true
        System.out.println("Hello".equals(str1));//true

        System.out.println("==============");

        String str4 = null;
        System.out.println("abc".equals(str4));//推荐 false
        //System.out.println(str4.equals("abc"));//不推荐 报错，空指针异常NullPointerException

        System.out.println("================");

        String strA = "java";
        String strB = "Java";
        System.out.println(strA.equals(strB));//false 严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB));//true 忽略大小写
    }
}

String当中与获取相关的常用方法有：

public int length()：获取字符串当中含有的字符个数，拿到字符串长度。

public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。

public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始）

public int indexOf(String str)：查找参数字符串在本字符串当中出现的索引位置，如果没有返回-1值。

public class Demo04_StringGet {
    public static void main(String[] args) {
        //获取字符串的长度
        int length = "dhfkdjhfwiekdj".length();
        System.out.println("字符串的长度是：" + length);

        //拼接字符串
        String str1 = "hello";
        String str2 = "world";
        String str3 = str1.concat(str2);
        System.out.println(str1);//hello
        System.out.println(str2);//world
        System.out.println(str3);//helloworld
        System.out.println("==============");

        //获取指定索引位置的单个字符
        char ch = "hello".charAt(1);
        System.out.println("在1号索引位置的字符是：" + ch);//e
        System.out.println("================");

        //查找参数字符串在本字符串当中出现的第一次的索引位置
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次出现的位置：" + index);//2

        System.out.println("HelloWorld".indexOf("abc"));//-1
    }
}

字符串的截取方法：

public String subString(int index):截取从参数位置一直到字符串末尾，返回新字符串。
public String subString(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。备注：[begin, end)

public class Demo05_SubString {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1);//HelloWorld
        System.out.println(str2);//World
        System.out.println("==============");

        String str3 = str1.substring(4, 7);
        System.out.println(str3);//oWo
        System.out.println("==============");

        //下面这种写法，字符串的内容仍然是没有改变的
        //两个字符串"Hello","Java"
        //strA当中保存的是地址值
        //本来的地址值是Hello的0x666
        //后来地址值变为Java的0x999
        String strA = "Hello";
        System.out.println(strA); //Hello
        strA = "Java";
        System.out.println(strA);//Java
    }
}

String当中与转换相关的常用方法有：

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。 public byte[]
getBytes()：获得当前字符串底层的字节数组。 public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence是可以接受字符串的类型

public class Demo06_StringConvert {
    public static void main(String[] args) {
        //转换成为字符数组
        char[] chars = "hello".toCharArray();
        System.out.println(chars[0]);//h
        System.out.println(chars[1]);//e
        System.out.println(chars.length);//5
        System.out.println("=============");

        //转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("=============");

        //替换字符串
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1);
        System.out.println(str2);
    }
}

分割字符串的方法：

public String[] split(String regex)：按照参数规则，将字符串切分成为若干部分。 注意事项：
split方法的参数其实是一个“正则表达式”，要注意，按照英文句点“.”进行切分，必须写“\.”(两个反斜杠)

public class Demo07_StringSplit {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        System.out.println("==============");

        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println("===============");

        String str3 = "aaa.bbb.ccc";
        String[] array3 = str3.split(".");
        System.out.println(array3.length);//0
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
        System.out.println("===============");

        String str4 = "XXX.YYY.ZZZ";
        String[] array4 = str4.split("\\.");
        System.out.println(array4.length);//3
        for (int i = 0; i < array4.length; i++) {
            System.out.println(array4[i]);
        }
    }
}

练习：
1、定义一个方法，把{1，2，3}按照指定格式拼接成一个字符串。格式参照如下：{word1#word2#word3}

public class Demo08_StringPractice {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        String str = fromArrayToString(array);
        System.out.println(str);
    }

    public static String fromArrayToString(int[] array){
        String str = "{";
        for (int i = 0; i < array.length; i++) {
            if(i != array.length - 1){
                str += "word" + array[i] + "#";
            }else{
                str += "word" + array[i] + "}";
            }
        }
        return str;
    }
}

2、键盘输入一个字符串，并且统计其中各种字符出现的次数。
种类有：大写字母、小写字母、数字、其他

public class Demo09_StringCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next();

        int countUpper = 0;//大写字母
        int countLower = 0;//小写字母
        int countNUmber = 0;//数字
        int countOther = 0;//其他

        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i];//当前单个字符
            if(ch >= 'A' && ch <= 'Z'){
                countUpper++;
            }else if(ch >= 'a' && ch <= 'z'){
                countLower++;
            }else if(ch >= '0' && ch <= '9'){
                countNUmber++;
            }else{
                countOther++;
            }
        }
        System.out.println("大写字母有：" + countUpper);
        System.out.println("小写字母有：" + countLower);
        System.out.println("数字有：" + countNUmber);
        System.out.println("其他有：" + countOther);
    }
}
6.static静态
如果一个成员使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据 
public class Student {
    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    static String room;//所在教室
    private static int idCounter = 0;//学号计数器，每当new一个新对象的时候，计数器++
    
    public Student() {
        this.id = ++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Demo01_StaticField {
    public static void main(String[] args) {
        Student one = new Student("郭靖", 20);
        one.room = "101教室";
        System.out.println("姓名：" + one.getName() +
                "，年龄：" + one.getAge() +
                "，教室：" + one.room +
                "，学号：" + one.getId());

        Student two = new Student("黄蓉", 18);
        System.out.println("姓名：" + two.getName() +
                "，年龄：" + two.getAge() +
                "，教室：" + two.room +
                "，学号：" + two.getId());
    }
}

一旦使用static修饰成员方法，它就成为了静态方法，静态方法不属于对象，而是属于类。
如果没有static关键字，那么必须首先创建对象，然后通过对象调用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()

注意事项：

  1. 静态不能直接访问非静态
    原因：内存当中是【先】有的静态内容，【后】有的非静态内容。
  2. 静态方法当中不能使用this关键字
    原因：this代表当前对象，通过谁调用方法，谁就是当前对象。
public class MyClass {
    int num;//成员变量
    static int numStatic;//静态变量

    public void Method(){
        System.out.println("这是一个成员方法。");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    public static void MethodStatic(){
        System.out.println("这是一个静态方法。");
        //静态不能直接访问非静态【重点】
//        System.out.println(num);//错误写法
        
        //静态方法可以直接访问静态变量
        System.out.println(numStatic);

        //静态方法中不能使用this关键字
//        System.out.println(this);//错误写法
    }
}

静态代码块的格式：

public class 类名称{
    static{
        //静态代码内容
    }
}

特点：当第一次使用到本类时，静态代码块执行唯一的一次。
静态内容总是优先非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途：
用来一次性的对静态成员变量赋值。

public class Person {
    static{
        System.out.println("静态代码块执行");
    }

    public Person(){
        System.out.println("构造方法执行");
    }
}

public class Demo04_Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}
7.Arrays工具类
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。 public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3...]） public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：

  1. 如果是数值，sort默认按照升序从小到大
  2. 如果是字符串，sort默认按照字母升序
  3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口支持。
import java.util.Arrays;

public class Demo01_Arrays {
    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        //将int数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);//[10, 20, 30]

        int[] array1 = {3, 1, 5, 10, 9};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[1, 3, 5, 9, 10]

        String[] array2 = {"bbb", "aaa", "ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }
}

练习：
1、请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印

import java.util.Arrays;

public class Demo02_ArraysPractice {
    public static void main(String[] args) {
        String str = "d782bhjbvk03dsa";

        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符数组进行升序排列

        //倒序遍历
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        } 
    }
}
8.Math类
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs(double num)：获取绝对值
public static double ceil(double num)：向上取整
public static double floor(double num)：向下取整
public static long round(double num)：四舍五入

public class Demo03_Math {
    public static void main(String[] args) {
        //绝对值
        System.out.println(Math.abs(3.14));//3.14
        System.out.println(Math.abs(-3));//3
        System.out.println("===========");

        //向上取整
        System.out.println(Math.ceil(2.4));//3.0
        System.out.println("===========");

        //向下取整
        System.out.println(Math.floor(3.8));//3.0
        System.out.println("===========");

        //四舍五入
        System.out.println(Math.round(2.9));//3
        System.out.println(Math.round(2.5));//3
    }
}

练习：
1、计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个

思路：
起点位置-10.8应该转换为-10，有两种方法：

  1. 强转为int，自动舍弃小数位
  2. 使用Math.ceil()方法，向上取整

备注：
如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++的。

public class Demo04_MathPractice {
    public static void main(String[] args) {
        int count = 0; //计数
        double min = -10.8;
        double max = 5.9;
        //这样处理，i就是区间之内所有的整数
        for (int i = (int)min; i < max; i++){
            int abs = Math.abs(i);
            if(abs > 6 || abs < 2.1){
                System.out.println(i);
                count++;
            }
        }
        System.out.println("整数有：" + count);
    }
}


public class Demo04_MathPractice {
    public static void main(String[] args) {
        int count = 0; //计数
        double min = -10.8;
        double max = 5.9;
        //这样处理，i就是区间之内所有的整数
        for (double i = Math.ceil(min); i < max; i++){
            double abs = Math.abs(i);
            if(abs > 6 || abs < 2.1){
                System.out.println(i);
                count++;
            }
        }
        System.out.println("整数有：" + count);
    }
}
# java
Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区
cover

用 OpenAI Assistants 做大模型应用开发

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区