常用API(一)、static关键字

最新推荐文章于 2022-06-27 16:28:25 发布

天阳在线€

最新推荐文章于 2022-06-27 16:28:25 发布

阅读量239

点赞数

分类专栏： javaSE

本文链接：https://blog.csdn.net/yangbo_CSDN/article/details/116139525

版权

javaSE 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1、API 应用程序接口

JDK包结构

2.Scanner类

2.1什么是Scanner类

在这里插入图片描述

2.2引用类型引用步骤

导包

创建对象

调用方法

2.3 Scanner使用步骤

在这里插入图片描述
使⽤Scanner类，完成接收键盘录⼊数据的操作，代码如下：

//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
 public static void main(String[] args) {
 //2. 创建键盘录⼊数据的对象
 Scanner sc = new Scanner(System.in);
 //3. 接收数据
 System.out.println("请录⼊⼀个整数:");
 int i = sc.nextInt();
 
 //4. 输出数据
 System.out.println("i:" + i);
 }
}

2.4练习
求和
键盘录入两个数据求和，代码如下：

import java.util.Scanner;
public class Test01Scanner {
 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 sum = a + b;
 System.out.println("sum:" + sum);
 }
}

取最值
键盘录⼊三个数据并获取最⼤值，代码如下：

import java.util.Scanner;

/*
* 求最值
* */
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数：");
        int b1=scanner.nextInt();
        System.out.println("请输入第二个数：");
        int b2=scanner.nextInt();
        System.out.println("请输入第三个数：");
        int b3=scanner.nextInt();
        int temp=(b1>b2?b1:b2);
        int MAx=(temp>b3?temp:b3);
        System.out.println("MAX:"+MAx);


    }
}

2.5 匿名对象

应用场景

3.匿名对象可以作为方法的参数和返回值
作为参数
作为返回值

3.Random类

3.1 什么是Random类

此类的实例用于生成伪代码随机数
例如：以下代码使用户能够得到一个随机数

Random random=new Random();
        int a=random.nextInt(2);
        System.out.println(a);

3.2 Random使用步骤

Random使用步骤

3.3 练习

获取随机数
获取1-n之间的随机数，包含n，代码如下：

import java.util.Random;

public class Demo02 {
    public static void main(String[] args) {
        //创建对象
        int n=100;
        Random random=new Random();
        //获取随机数
        int a=random.nextInt(n)+1;
        System.out.println(a);
    }
}

猜数字小游戏
题目要求

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

/*游戏开始时，会随机⽣成⼀个1-100之间的整数 number 。玩家猜测⼀个数字 guessNumber ，会
与 number 作⽐较，系统提示⼤了或者⼩了，直到玩家猜中，游戏结束。*/
public class Demo03 {
    public static void main(String[] args) {

        Random random = new Random();
        int number=random.nextInt(100)+1;
        System.out.println(number);while (true){

            Scanner scanner=new Scanner(System.in);
            System.out.println("输入你所猜测的数字：");
            int guessNumber=scanner.nextInt();
            compare(number,guessNumber);
            if (number==guessNumber){
                break;
            }
        }

    }
    public  static  void compare(int number,int guessNumber){
        if (number>guessNumber){
            System.out.println("猜小啦！");
        }else if (number<guessNumber){
            System.out.println("猜大啦！");
        }else{
            System.out.println("猜对啦!");
        }
    }
}

4.String类

string
使用步骤

4.3 常用方法

判断功能的方法

public class String_Demo01 {
 public static void main(String[] args) {
 // 创建字符串对象
 String s1 = "hello"; 1234
 String s2 = "hello";
 String s3 = "HELLO";
 // boolean equals(Object obj):⽐较字符串的内容是否相同
 System.out.println(s1.equals(s2)); // true
 System.out.println(s1.equals(s3)); // false
 System.out.println("-----------");
 // boolean equalsIgnoreCase(String str):⽐较字符串的内容是否相同,忽略
⼤⼩写
 System.out.println(s1.equalsIgnoreCase(s2)); // true
 System.out.println(s1.equalsIgnoreCase(s3)); // true
 System.out.println("-----------");
 } }

Object 是“对象”的意思，也是⼀种引⽤类型。作为参数类型，表示任意对象都可以传递到⽅法中。

获取功能的方法
public int length() ：返回此字符串的⻓度。
public String concat(String str) ：将指定的字符串连接到该字符串的末尾。
public char charAt(int index) ：返回指定索引处的char值。
public int indexOf(String str) ：返回指定⼦字符串第⼀次出现在该字符串内的索引。
public String substring(int beginIndex) ：返回⼀个⼦字符串，从beginIndex开始截取字符串到字符串结尾。
public String substring(int beginIndex, int endIndex) ：返回⼀个⼦字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
⽅法演示，代码如下：

public class String_Demo {

    public static void main(String[] args) {
        // 创建字符串对象
        String s = "helloworld";

        // int length():获取字符串的⻓度，其实也就是字符个数
        System.out.println(s.length());
        System.out.println("--------");

        // String concat (String str):将将指定的字符串连接到该字符串的末尾
        s = "helloworld";
        String s2 = s.concat("**hello bonnie");
        System.out.println(s2); // helloworld**hello bonnie
        // char charAt(int index):获取指定索引处的字符
        System.out.println(s.charAt(0));
        System.out.println(s.charAt(1));
        System.out.println("--------");

        // int indexOf(String str):获取str在字符串对象中第⼀次出现的索引,没有返回-1
        System.out.println(s.indexOf("l"));
        System.out.println(s.indexOf("owo"));
        System.out.println(s.indexOf("ak"));
        System.out.println("--------");

        // String substring(int start):从start开始截取字符串到字符串结尾
        System.out.println(s.substring(0));
        System.out.println(s.substring(5));
        System.out.println("--------");

        // String substring(int start, int end):从start到end截取字符串。含start，不含end。
        System.out.println(s.substring(0, s.length()));
        System.out.println(s.substring(3,8));
    } }

成果截图
转换功能的⽅法
public char[] toCharArray() ：将此字符串转换为新的字符数组。
public byte[] getBytes() ：使⽤平台的默认字符集将该String编码转换为新的字节数组。
public String replace(CharSequence target, CharSequence replacement) ：将与target匹配的字符串使⽤replacement字符串替换。
⽅法演示，代码如下：

package api1;

import java.util.Arrays;

public class String_DEmo01 {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1="abcde";
        //public char[] toCharArray() ：将此字符串转换为新的字符数组。
        char[] chars=s1.toCharArray();
        for (int i = 0; i <chars.length ; i++) {
            System.out.println(chars[i]);
        }
        System.out.println("_________");
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes=s1.getBytes();
        for (int i = 0; i <bytes.length ; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("---------");

        // 替换字⺟liu为⼤写Liu
        String s="liu";
        String s2=s.replace("l","L");
        System.out.println(s2);
    }

}

成果截图
CharSequence 是⼀个接⼝，也是⼀种引⽤类型。作为参数类型，可以把String对象传递到⽅法中。

分割功能的⽅法
public String[] split(String regex) ：将此字符串按照给定的regex(规则)拆分为字符串数组。
⽅法演示，代码如下：

public class String_Demo03 {
 public static void main(String[] args) {
 // 创建字符串对象
 String s = "aa|bb|cc";
 String[] strArray = s.split("|"); // ["aa","bb","cc"]
 for (int x = 0; x < strArray.length; x++) {
 System.out.println(strArray[x]); // aa bb cc
 }
 }}

4.4 String类的练习

拼接字符串
定义⼀个⽅法，把数组 {1, 2, 3} 按照指定个格式拼接成⼀个字符串。格式参照如下：
[word1#word2#word3]。

package api1;
/*拼接字符串*/
public class String_Test1 {
    public static void main(String[] args) {
        int [] arr={1,2,3};
        String s=arrToString(arr);
        System.out.println("s:"+s);
    }
     /*
 * 写⽅法实现把数组中的元素按照指定的格式拼接成⼀个字符串
 * 两个明确：
 * 返回值类型: String
 * 参数列表: int[] arr
 */
    public static String arrToString(int[] arr){
        String s=new String("[");
        // 遍历数组，并拼接字符串
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                s=s.concat(arr[i]+"]");
            }else{
                s=s.concat(arr[i]+"#");
            }
        }
        return s;
    }
}

统计字符个数
键盘录⼊⼀个字符串，统计字符串中⼤⼩写字⺟及数字字符个数。

package api1;

import java.util.Scanner;

public class StringTest2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s=scanner.nextLine();

        int bigCount=0;
        int smallCount=0;
        int numberCount=0;

        for (int i = 0; i <s.length() ; i++) {
            char ch=s.charAt(i);
            if (ch>='A'&& ch<='Z'){
                bigCount++;
            }else if (ch>='a'&& ch<='z'){
                smallCount++;
            }else if (ch>='0' && ch<='9'){
                numberCount++;
            }else{
                System.out.println("字符"+ch+"错误");
            }

        }
        System.out.println("大写字母个数："+bigCount);
        System.out.println("小写字母个数："+smallCount);
        System.out.println("数字的个数："+numberCount);
    }
}

成果截图

5.ArrayList类

5.1 引⼊ – 对象数组

使⽤学⽣数组，存储三个学⽣对象，代码如下：

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;
 }
 publicint getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }}

public class Test01StudentArray {
 public static void main(String[] args) {
 // 创建学⽣数组
 Student[] students = new Student[3];
 
 // 创建学⽣对象
 Student s1 = new Student("曹操",40);
 Student s2 = new Student("刘备",35);
 Student s3 = new Student("孙权",30);
 
 // 把学⽣对象作为元素赋值给学⽣数组
 students[0] = s1;
 students[1] = s2;
 students[2] = s3;
 
 // 遍历学⽣数组
 for(int x = 0; x < students.length; x++) {
 Student s = students[x];
 System.out.println(s.getName() + "---" + s.getAge());
 }
 } }

到⽬前为⽌，我们想存储对象数据，选择的容器，只有对象数组。⽽数组的⻓度是固定的，⽆法适应数据变化的需求。为了解决这个问题，Java提供了另⼀个容器 java.util.ArrayList 集合类，让我们可以更便捷的存储和操作对象数据。

5.2 什么是ArrayList类

java.util.ArrayList 是⼤⼩可变的数组的实现，存储在内的数据称为元素。此类提供⼀些⽅法来操作内部存储的元素。 ArrayList 中可不断添加元素，其⼤⼩也⾃动增⻓。

5.3 ArrayList使⽤步骤

使用步骤
构造方法
查看成员⽅法
public boolean add(E e) ：将指定的元素添加到此集合的尾部。
参数 E e ，在构造ArrayList对象时，指定了什么数据类型，那么 add(E e) ⽅法中，只能添加什么数据类型的对象。
使⽤ArrayList类，存储三个字符串元素，代码如下：

public class Test02StudentArrayList {
 public static void main(String[] args) {
 // 创建学⽣数组
 ArrayList<String> list = new ArrayList<>();
 // 创建学⽣对象
 String s1 = "曹操";
 String s2 = "刘备";
 String s3 = "孙权";
 // 打印学⽣ArrayList集合
 System.out.println(list);
 // 把学⽣对象作为元素添加到集合
 list.add(s1);
 list.add(s2);
 list.add(s3);
 
 // 打印学⽣ArrayList集合
 System.out.println(list);
 }
}

5.4 常⽤⽅法和遍历

对于元素的操作，基本体现在 – 增、删、查。
常⽤的⽅法有：
public boolean add(E e) ：将指定的元素添加到此集合的尾部。
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防⽌越界。
这些都是最基本的⽅法，操作⾮常简单，代码如下：

public class Demo01ArrayListMethod {
 public static void main(String[] args) {
 // 创建集合对象
 ArrayList<String> list = new ArrayList<String>();
 // 添加元素
 list.add("hello");
 list.add("world");
 list.add("java");
 // public E get(int index):返回指定索引处的元素
 System.out.println("get:" + list.get(0));
 System.out.println("get:" + list.get(1));
 System.out.println("get:" + list.get(2));
 
 // public int size():返回集合中的元素的个数
 System.out.println("size:" + list.size());
 // public E remove(int index):删除指定索引处的元素，返回被删除的元素 
 System.out.println("remove:" + list.remove(0));
 // 遍历输出
 for(int i = 0; i < list.size(); i++) {
 System.out.println(list.get(i));
 }
 } }

5.5 如何存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引⽤类型的数据。类似不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：

我们发现，只有 Integer 和 Character 需要特殊记忆，其他基本类型只是⾸字⺟⼤写即可。那么存储基本类型数据，代码如下：

public class Demo02ArrayListMethod {
 public static void main(String[] args) {
 ArrayList<Integer> list = new ArrayList<Integer>();
 list.add(1);
 list.add(2);
 list.add(3);
 list.add(4);
 System.out.println(list);
 } }

5.6 ArrayList练习

数值添加到集合
⽣成6个1~33之间的随机整数，添加到集合，并遍历

package api1;

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

public class Test01Arrylist {
    public static void main(String[] args) {
        // 创建Random 对象
        Random random=new Random();
        // 创建Arraylist 对象
        ArrayList<Integer> arr=new ArrayList<>();

        // 添加随机数到集合
        for (int i = 0; i <6 ; i++) {
            int ran=random.nextInt(33)+1;
            arr.add(ran);
        }
        // 遍历集合输出
        for (int i = 0; i <arr.size() ; i++) {
            int list=arr.get(i);
            System.out.println(list);
            
        }
    }
}

对象添加到集合
⾃定义4个学⽣对象，添加到集合，并遍历

package api1;

import java.util.ArrayList;

public class Test02Arraylist {
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        // 创建学⽣对象
        Student s1=new Student("刘备",22);
        Student s2=new Student("张飞",20);
        Student s3=new Student("关羽",220);
        Student s4=new Student("子龙",2);
        // 把学⽣对象作为元素添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        for (int i = 0; i <list.size() ; i++) {
            Student stu=list.get(i);
            System.out.println(stu.getName()+"--"+stu.getAge());
   }
}

        }

打印集合⽅法
定义以指定格式打印集合的⽅法（ArrayList类型作为参数），使⽤{}扩起集合，使⽤@分隔每个元素。
格式参照 {元素@元素@元素}。

package api1;

import java.util.ArrayList;

public class Test03Arraylist {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("楚枫");
        list.add("楚轩辕");
        list.add("楚瀚仙");
        arrPrint(list);
    }
    public static void arrPrint(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i <list.size() ; i++) {
            String str=list.get(i);
            if (i!=list.size()-1){
                System.out.print(str+"@");
            }else{
                System.out.print(str+"}");
            }
        }    }
}

在这里插入图片描述
获取集合⽅法
定义获取所有偶数元素集合的⽅法（ArrayList类型作为返回值）

package api1;

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

public class Test04List {
    public static void main(String[] args) {
        // 创建Random 对象
        Random random=new Random();
        // 创建ArrayList 对象
        ArrayList<Integer> list=new ArrayList<>();
        // 添加随机数到集合
        for (int i = 0; i <20 ; i++) {
            int s=random.nextInt(400);
            list.add(s);
        }
        // 调⽤偶数集合的⽅法
        ArrayList<Integer> s= evenNumber(list);
        System.out.println(s);

    }
    public static ArrayList<Integer> evenNumber(ArrayList<Integer> list){
        // 创建⼩集合,来保存偶数
        ArrayList<Integer> smalllist=new ArrayList<>();
        // 遍历list
        for (int i = 0; i <list.size() ; i++) {
            // 获取元素
            Integer s=list.get(i);
            // 判断为偶数,添加到⼩集合中
            if (s%2==0){
                smalllist.add(s);
            }
        }
        // 返回⼩集合
        return smalllist;
    }
}

6 static关键字

6.1 概述

关于 static 关键字的使⽤，它可以⽤来修饰的成员变量和成员⽅法，被修饰的成员是属于类的，⽽不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调⽤了。

6.2 定义和使⽤格式

类变量
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同⼀个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进⾏操作。
类变量：使⽤static关键字修饰的成员变量。
在这里插入图片描述
⽐如说，基础班新班开班，学员报到。现在想为每⼀位新来报到的同学编学号（sid），从第⼀名同学开始，sid为1，以此类推。学号必须是唯⼀的，连续的，并且与班级的⼈数相符，这样以便知道，要分配给下⼀名新同学的学号是多少。这样我们就需要⼀个变量，与单独的每⼀个学⽣对象⽆关，⽽是与整个班级同学数量有关。
所以，我们可以这样定义⼀个静态变量numberOfStudent，代码如下：

public class Student {
 private String name;
 private int age;
 // 学⽣的id
 private int sid;
 // 类变量，记录学⽣数量，分配学号
 public static int numberOfStudent = 0;
 
 public Student(String name, int age) {
 this.name = name;
 this.age = age;
 // 通过 numberOfStudent 给学⽣分配学号
 this.sid = ++numberOfStudent;
 }
 
 // 打印属性值
 public void show() {
 System.out.println("Student : name=" + name + ", age=" + age + ", sid="
+ sid);
 }
}

public class StuDemo {
 public static void main(String[] args) {
 Student s1 = new Student("张三", 23);
 Student s2 = new Student("李四", 24);
 Student s3 = new Student("王五", 25);
 Student s4 = new Student("赵六", 26);
 s1.show(); // Student : name=张三, age=23, sid=1
 s2.show(); // Student : name=李四, age=24, sid=2
 s3.show(); // Student : name=王五, age=25, sid=3
 s4.show(); // Student : name=赵六, age=26, sid=4
 } }

静态⽅法
当 static 修饰成员⽅法时，该⽅法称为类⽅法。静态⽅法在声明中有 static ，建议使⽤类名来调⽤，⽽不需要创建类的对象。调⽤⽅式⾮常简单。
类⽅法：使⽤static关键字修饰的成员⽅法，习惯称为静态⽅法。
在这里插入图片描述

6.3 静态原理图解

static 修饰的内容：
是随着类的加载⽽加载的，且只加载⼀次。
存储于⼀块固定的内存区域（静态区），所以，可以直接被类名调⽤。
它优先于对象存在，所以，可以被所有对象共享。
在这里插入图片描述

6.4 静态代码块

**静态代码块：**定义在成员位置，使⽤static修饰的代码块{ }。
位置：类中⽅法外。
执⾏：随着类的加载⽽执⾏且执⾏⼀次，优先于main⽅法和构造⽅法的执⾏。
格式：
在这里插入图片描述

7 Arrays类

7.1 概述

java.util.Arrays 此类包含⽤来操作数组的各种⽅法，⽐如排序和搜索等。其所有⽅法均为静态⽅法，调⽤起来⾮常简单。

7.2 操作数组的⽅法

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

public static void main(String[] args) {
 // 定义int 数组
 int[] arr = {2, 34, 35, 4, 657, 8, 69, 9};
 // 打印数组,输出地址值
 System.out.println(arr); // [I@2ac1fdc4
 
 // 数组内容转为字符串
 String s = Arrays.toString(arr);
 // 打印字符串,输出内容
 System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
}

public static void sort(int[] a) ：对指定的 int 型数组按数字升序进⾏排序。

public static void main(String[] args) {
 // 定义int 数组
 int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
 System.out.println("排序前:" + Arrays.toString(arr)); // 排序前:[24, 7,
5, 48, 4, 46, 35, 11, 6, 2]
 // 升序排序
 Arrays.sort(arr);
 System.out.println("排序后:" + Arrays.toString(arr)); // 排序后:[2, 4,
5, 6, 7, 11, 24, 35, 46, 48]
}

public static int[] copyOf(int[] original, int newLength) ：复制指定的数组，如有必要，⽤零填充。

public static void main(String[] args) {
 int[] arr = {1, 3, 5, 7, 9};
 // 数组扩容，⻓度 + 1
 arr = Arrays.copyOf(arr, 6);
 System.out.println("新数组:" + Arrays.toString(arr)); // 复制后，新数组
内容为:[1, 3, 5, 7, 9, 0]，新增位置填充0
 
 // 数组缩容，⻓度 - 1
 arr = Arrays.copyOf(arr, 4);
 System.out.println("新数组:" + Arrays.toString(arr)); // 复制后，新数组
内容为:[1, 3, 5, 7]
}

7.3 练习

请使⽤ Arrays 相关的API，将⼀个随机字符串中的所有字符升序排列，并倒序打印。

package api1;

import java.util.Arrays;

public class ArraysTest01 {
    public static void main(String[] args) {
        // 定义随机的字符串
        String s="dwkuifJkOLID";
        // 转换为字符数组
        char[] chars=s.toCharArray();
        // 升序排序
        System.out.println(Arrays.toString(chars));
        Arrays.sort(chars);
        // 反向遍历打印[d, w, k, u, i, f, J, k, O, L, I, D]
        for (int i = chars.length-1; i <=0 ; i--) {
            System.out.println(chars[i]);

        }
    }
}

8 Math类

8.1 概述

java.lang.Math 类包含⽤于执⾏基本数学运算的⽅法，如初等指数、对数、平⽅根和三⻆函数。类似这样的⼯具类，其所有⽅法均为静态⽅法，并且不会创建对象，调⽤起来⾮常简单。

8.2 基本运算的⽅法

public static double abs(double a) ：返回 double 值的绝对值。

double d1 = Math.abs(-5); // d1的值为5
double d2 = Math.abs(5); // d2的值为5

public static double ceil(double a) ：返回⼤于等于参数的最⼩的整数。

double d1 = Math.ceil(3.3); // d1的值为 4.0
double d2 = Math.ceil(-3.3); // d2的值为 -3.0
double d3 = Math.ceil(5.1); // d3的值为 6.0

public static double floor(double a) ：返回⼩于等于参数最⼤的整数。

double d1 = Math.floor(3.3); // d1的值为3.0
double d2 = Math.floor(-3.3); // d2的值为-4.0
double d3 = Math.floor(5.1); // d3的值为 5.0

public static long round(double a) ：返回最接近参数的 long。（相当于四舍五⼊⽅法）

long d1 = Math.round(5.5); // d1的值为6.0
long d2 = Math.round(5.4); // d2的值为5.0

8.3 练习

请使⽤ Math 相关的API，计算在 -10.8 到 5.9 之间，绝对值⼤于 6 或者⼩于 2.1 的整数有多少个？

package api1;

public class MathTest {
    public static void main(String[] args) {
        // 定义最⼩值
        double min = -10.8;
        // 定义最⼤值
        double max = 5.9;
        // 定义变量计数
        int count = 0;
        // 范围内循环
        for (double i = Math.ceil(min); i <= max; i++) {
            // 获取绝对值并判断
            if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                // 计数
                count++;
            }
        }
        System.out.println("个数为: " + count + " 个");//
9}}

9 System类

java.lang.System 类中提供了⼤量的静态⽅法，可以获取与系统相关的信息或系统级操作，在
System类的API⽂档中，常⽤的⽅法有：
public static long currentTimeMillis() ：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos,int length) ：将数组中指定的数据拷⻉到另⼀个数组中。

9.1 currentTimeMillis⽅法

实际上，currentTimeMillis⽅法就是获取当前系统时间与1970年01⽉01⽇00:00点之间的毫秒差值

import java.util.Date;
public class SystemDemo {
 public static void main(String[] args) {
 //获取当前时间毫秒值
 System.out.println(System.currentTimeMillis()); // 1516090531144
 }
}

练习
验证for循环打印数字1-9999所需要使⽤的时间（毫秒）

public class SystemTest1 {
 public static void main(String[] args) {
 long start = System.currentTimeMillis();
 for (int i = 0; i < 10000; i++) {
 System.out.println(i);
 }
 long end = System.currentTimeMillis();
 System.out.println("共耗时毫秒：" + (end - start));
 }
}

9.2 arraycopy⽅法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos,int length) ：将数组中指定的数据拷⻉到另⼀个数组中。数组的拷⻉动作是系统级的，性能很⾼。System.arraycopy⽅法具有5个参数，含义分别为：
在这里插入图片描述
练习
将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

import java.util.Arrays;
public class Demo11SystemArrayCopy {
 public static void main(String[] args) {
 int[] src = new int[]{1,2,3,4,5};
 int[] dest = new int[]{6,7,8,9,10};
 System.arraycopy( src, 0, dest, 0, 3);
 /*代码运⾏后：两个数组中的元素发⽣了变化
 src数组元素[1,2,3,4,5]
 dest数组元素[1,2,3,9,10]
 */
 }
}

天阳在线€

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用API(一)、static关键字

1、API 应用程序接口2.Scanner类2.1什么是Scanner类2.2引用类型引用步骤导包创建对象调用方法2.3 Scanner使用步骤使⽤Scanner类，完成接收键盘录⼊数据的操作，代码如下：//1. 导包import java.util.Scanner;public class Demo01_Scanner { public static void main(String[] args) { //2. 创建键盘录⼊数据的对象 Scanner sc =
复制链接

扫一扫