Java常用的API（应用程序编译接口）

最新推荐文章于 2022-04-06 19:13:23 发布

Y动动

最新推荐文章于 2022-04-06 19:13:23 发布

阅读量352

点赞数

分类专栏： Java基础知识文章标签： java

本文链接：https://blog.csdn.net/m0_50837538/article/details/109228455

版权

Java基础知识专栏收录该内容

22 篇文章 0 订阅

订阅专栏

文章目录

Sacnner类
匿名对象
random类
ArragLIst集合
String类
Static静态类
Arrays类
Math类

Sacnner类

步骤

导包（import 包路径.类名称）【如果使用的类和当前类在同一个包，可以省略这一步】
创建
使用
Sacnner例子

package cn.itcast.day01.demo01;

import java.util.Scanner;//导包

public class ScannerSum {
    public static void main(String args[]){
        Scanner scan =new Scanner(System.in);//创建
        int[] A=new int[3];
         A[0]=scan.nextInt();//使用
         A[1]=scan.nextInt();
         A[2]=scan.nextInt();
        int min=A[0];
        for (int i=1;i<A.length;i++){
            if(A[i]<min)
            {min=A[i];}

        }
        System.out.println(min);

    }
}

匿名对象

创建对象的标准格式
类名称对象名=new 类名称();
匿名对象的创建
new 类名称(); 注意事项：只能使用唯一的一次，下次再用在创建一个新的对象；建议使用：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象
举例
标准的格式

package cn.itcast.day01.demo01;
import java.util.Scanner;
public class DemoStudent {
    public static  void main(String[] args){

       /* Student stu=new Student();
        stu.name="Y动动";
        stu.age=24;
        stu.sex='女';
        stu.eat();
        stu.sleep();
        stu.study("Java");*/
        new Student().name="Y动动";
        new Student().eat();
    }
}

匿名对象的不同使用

import com.sun.source.tree.NewArrayTree;
import java.util.Scanner;
public class Anonymous {
    public static void main(String args[]){
        //标准的使用方式
        Scanner s=new Scanner(System.in);
        int n=s.nextInt();
        System.out.println(n);
        //匿名对象的使用方法
        int m=new Scanner(System.in).nextInt();
        System.out.println(m);
        //匿名对象可以写入参数
       Param(new Scanner(System.in));//传匿名对象参数
        //返回匿名对象
        Scanner S=retu();//返回匿名对象
        int b=S.nextInt();
        System.out.println(b);

    }
        public static void Param(Scanner s){
        int m= s.nextInt();
        System.out.println(m);

       }

       public  static Scanner retu(){

        return (new Scanner(System.in));
       }

}

random类

步骤

导包（import 包路径.类名称）【如果使用的类和当前类在同一个包，可以省略这一步】
创建
使用
猜谜游戏

package cn.itcast.day01.demo01;
import java.util.Random;
import java.util.Scanner;
import java.util.stream.StreamSupport;
public class guss {
    public static void main(String args[]){
        Scanner s=new Scanner(System.in);
        System.out.println("请输入参数");
        int m= s.nextInt();
        Random r=new Random();
        int n=r.nextInt(100);
        while(n!=m) {
            if (n > m) {
                System.out.println("太小了，重新输入");
                 m= s.nextInt();
            }
            else {
                System.out.println("太大了，重新输入");
                m= s.nextInt();
            }
        }
        System.out.println("猜对啦");
        System.out.println(n);
    }
}

ArragLIst集合

创建有参和无参成员函数：快捷键：Alt+Insert(插入)–>construct–>全选或者不选
创建成员函数：快捷键：Alt+Insert(插入)–>Getter and Setter–>全选
导包：

import java.util.ArrayList;

基本格式：在这里插入图片描述

ArrayList<Student> list=new ArrayList<>();`

常用的成员函数：

public boolean add(E e):将指定元素添加到集合的尾部
public E remove(int index)：一处在集合中的指定位置元素，返回删除的元素
public E get(int index)：获取在集合该位置的元素，返回该位置的元素
public int size()：返回该集合中的元素位置。可以用于元素的遍历

package cn.itcast.day01.demo3;
public class Student {
  private String name;
  private int age;
    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;
    }
}

package cn.itcast.day01.demo3;
import javax.naming.Name;
import java.util.ArrayList;
import java.util.List;
public class demoStudentArrayList {
    public static void main(String args[]){
        ArrayList<Student> list=new ArrayList<>();
        Student one =new Student("yjj1",24);
        Student two =new Student("yjj2",23);
        Student three =new Student("yjj3",25);
        list.add(one);
        list.add(two);
        list.add(three);
        for (int i = 0; i < list.size(); i++) {
            Student s=list.get(i);
            System.out.println("name："+s.getName()+"age:"+s.getAge());
        }
    }
}

如何存储基本数据类型

基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	boolean

== 举例==
打印ArrayList里的内容

package cn.itcast.day01.demo3;
import java.util.ArrayList;
public class printArrayList {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("yjj1");
        list.add("yjj2");
        list.add("yjj3");
        list.add("yjj4");
        list.add("yjj5");
        System.out.println(list);
        shuchu(list);
    }
    public static void shuchu(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            if(i==list.size()-1){
                System.out.print(list.get(i)+"}");
            }
            else
                System.out.print(list.get(i)+"@");
        }

    }
}

输出结果：
在这里插入图片描述
输出ArrayList中偶数集合元素

package cn.itcast.day01.demo3;
import java.nio.channels.NonWritableChannelException;
import java.util.ArrayList;
import java.util.Random;
public class Array {
    public static void main(String[] args) {
        ArrayList<Integer> list1=new ArrayList<>();
        Random r =new Random();int j=0;
        for (int i = 0; i < 20; i++) {
          int n=  r.nextInt(30)+1;
          list1.add(n);
        }
        System.out.println(list1);
        ArrayList<Integer> list2=new ArrayList<>();
        list2= getsmalllist(list1);
        System.out.println(list2);
    }
    public static ArrayList<Integer> getsmalllist(ArrayList<Integer> list){
    ArrayList<Integer> list2=new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i)%2==0){
                list2.add(list.get(i));
            }
        }
        return list2;
    }
}

输出结果
在这里插入图片描述

String类

API当中：Java程序中所有道德字符串值都作为此类的实例实现。当程序中所有的双引号字符，都说是String类的对象。【就算没有new，也可以】
字符串的特点：

字符串的内容永不变
字符串可以共享
字符串效果上相当于char[]数组，底层原理是byte[]字节数组
创建字符串的常见3+1方式
public String（）；//创建一个空字符串
public String（char[] array）；//根据字节组内容，创建对应的字符串
public String（byte[] array）；//根据字节组内容，创建对应的字符串
String str=“hello”；

package cn.itcast.day01.demo04;
public class differentString {
    public static void main(String[] args) {
        String s1=new String();
        System.out.println("第一个构造方式："+s1);
        char[] c={'1','2','3'};
        String s2=new String(c);
        System.out.println("第二个构造方式："+s2);
        byte[] b={97,98,99};
        String s3=new String(b);
        System.out.println("第三个构造方式："+s3);
        String str="hello";
        System.out.println("直接创建方式："+str);
    }
}

运行结果：
在这里插入图片描述
字符串常量池
“” 是进行对象的地址值比较，如果确实需要字符串内容进行比较，可以使用两个方法：
public bollean equals（Object obj;严格区分大小写
public bollean equalsignoreCase（Object obj;不区分大小写
注意事项：
1.任何对象都能用Object进行接受。
2.具有对称性
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面建议（“abc”.equals（str)）==【null.equal(“hello”)空指针异常】
在这里插入图片描述
String常用的方法
public int length():获取字符串的长度
public String concat（String str):将当前字符串和参数字符串进行拼接，返回拼接字符串。
public char charAt（int index）：获取相应索引位置的字符。
public int indexof（string str):查找参数字符串在本字符串当中首次川线的索引位置，如果没有返回-1

package cn.itcast.day01.demo04;
public class hanshu {
    public static void main(String[] args) {
        int length="BNMHHFYGFTYTYUY".length();
        System.out.println(length);
        String str1="hello";
        String str2="world";
        String str3=str1.concat(str2);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        char a=str1.charAt(3);
        System.out.println("第三个字符是"+a);
        int i=str1.indexOf('l');
        System.out.println("第一次出现l的位置是"+i);
    }
}

运行结果：
在这里插入图片描述
字符串的截取
public String substring（int index）;截取参数位置一直到字符串末尾，返回新字符串
public String substring(int begin,int end):截取从begin开始一直到end结束，中间的字符串【begin，end），包含左边不包含右边。

package cn.itcast.day01.demo04;
public class substring {
    public static void main(String[] args) {
        String str1="HelloWorld";
        String str2=str1.substring(5);
        String str3=str1.substring(2,9);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        //下面的这种写法，字符串的内容仍然是没有改变的
        //下面的这两个字符串：“Hello”，“Java”，改变的只是不同字符串的地址，内容没面
        String strA="Hello";
        System.out.println(strA);
        strA="World";
        System.out.println(strA);
    }
}

输出结果：
字符串的转换

 public char[] toCharArray();//将当前字符串拆成字符数组作为返回值
 public byte[] getByte();//获得当前字符串底层的字节数组
 public String replace(CharSequence oldString,CharSequence newString);
    //将所有出现的老字符串替换成为新的字符串，返回替换完的之后的新字符串

举例：

package cn.itcast.day01.demo04;
import java.security.PublicKey;
public class converString {
    public static void main(String[] args) {
   String str1="helloWorld";
   char[] str2=str1.toCharArray();
   System.out.println("第四个字符是："+str2[3]);
   System.out.println("第五个字符是："+str2[4]);
   String str3="abcde";
   byte[] str4=str3.getBytes();
        for (int i = 0; i < 5; i++) {
            System.out.println(str4[i]);
        }
        String str5="Hello,world!Hello,world!Hello,world!Hello,world!";
        String str6=str5.replace("world"," A Wonderful day");
        System.out.println(str6);

    }
}

运行结果：
在这里插入图片描述
字符串的分割

public String[] split (string regex);

split的参数是一个“正则表达式”。英文句点“.”分割，要“\.”才可以分割
举例：

package cn.itcast.day01.demo04;
public class stringSplit {
    public static void main(String[] args) {
    String str1="qqq,www,eee,rrr";
    String[] array1=str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println("第"+i+"段字符串是"+array1[i]);
        }
        System.out.println("*************************************");
        String str2="aaa bbb ccc ddd eee";
        String[] array2=str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println("第"+i+"段字符串是"+array2[i]);
        }
        System.out.println("*************************************");
        String str3="qqq.www.eee.rrr.ttt.yyy";
        String[] array3=str3.split("\\.");
        for (int i = 0; i < array3.length; i++) {
            System.out.println("第"+i+"段字符串是"+array3[i]);
        }
        System.out.println("*************************************");

    }
}

运行结果：
在这里插入图片描述
字符串的添加
str+=“”；在字符串后加入新的字符串(int,float,double,byte,str等)
举例：定义一个方法将数组[1,2,3]按照指定格式拼接成变成字符串；格式为[word1#word2#word3#]

package cn.itcast.day01.demo04;
public class stringPractise {
    public static void main(String[] args) {
        int[] array1={1,2,3};
        String str1=fromArrayToString(array1);
        System.out.println(str1);
    }
    public static String fromArrayToString(int[] a){
     String str="[" ;
        for (int i = 0; i < a.length; i++) {
            if(i== a.length-1)
                str+="word"+a[i]+"]";
            else
                str+="word"+a[i]+"#";
        }
       return str;
    }
}

运行结果：
在这里插入图片描述
定义计算不同字符串中不同字符个数的功能方法，大写字母个数，小写字母个数，数字个数，其他字符的个数
代码：

package cn.itcast.day01.demo04;
import java.util.Scanner;
public class stringCount {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("请输入一串字符串:");
        String str1=s.next();
        char[] charArray=str1.toCharArray();

      int countUpper=0;
      int countLower=0;
      int countNumber=0;
      int countOther=0;
        for (int i = 0; i < charArray.length; i++) {
            if(charArray[i]>='A'&&charArray[i]<='Z')
                countUpper++;
            else if (charArray[i]>='a'&&charArray[i]<='z')
                countLower++;
            else if(charArray[i]>='0'&& charArray[i]<='9')
                countNumber++;
            else
                countOther++;
        }
       System.out.println("大写字母有："+countUpper);
        System.out.println("小字母有："+countLower);
        System.out.println("数字有："+countNumber);
        System.out.println("其他有："+countOther);
    }
}

运行结果：
在这里插入图片描述

Static静态类

student类：

package cn.itcast.day01.demo04;
public class Student {
    private  int id;//实例变量
    private String name;//实例变量
    private int age;//实例变量（实例调用）
    static String room;//类变量（类和实例都可以调用）
    private static int idcounder=0;//静态的使用
    public Student() { idcounder++; }
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id=idcounder++;
    }
    public  static String getRoom() { return room; }//
    public static void setRoom(String room) { Student.room = room; }
    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; }
}

主函数：

package cn.itcast.day01.demo04;
public class StaticFoeld {
    public static void main(String[] args) {
         Student one=new Student("yjj1",19);
         Student two=new Student("yjj2",20);
         Student three=new Student("yjj3",21);//实例变量
         Student.room="机电楼534";//类变量
         //one.room="机电楼533";
         System.out.println("姓名："+one.getName()+", id："+one.getId()+", 年龄："+one.getAge()+", 实验室："+one.getRoom());
         System.out.println("姓名："+two.getName()+", id："+two.getId()+", 年龄："+two.getAge()+", 实验室："+two.room);
         System.out.println("姓名："+three.getName()+", id："+three.getId()+", 年龄："+three.getAge()+", 实验室："+two.room);
    }
}

运行结果：

姓名：yjj1, id：0, 年龄：19, 实验室：机电楼534
姓名：yjj2, id：1, 年龄：20, 实验室：机电楼534
姓名：yjj3, id：2, 年龄：21, 实验室：机电楼534

注意事项：

Static修饰成员方法，那么这就成为了静态方法。静态方法属于类的，不属于对象。
如果没有static关键字，必须首先创建对象，然后通过对象使用它。
如果有了static关键字，不需要创建对象，直接就可以通过类名称来使用它。
无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量；静态方法：类名称.静态方法()。
【静态】不能直接访问【非静态】。原因是因为在内存中【先】有静态内容，【后】有非静态内容。
静态方法中不能用this。原因是：this代表当前对象，通过谁调用的方法，谁就是当前对象。

	静态变量	非静态变量	静态方法	非静态方法
类	OK	NO	OK	NO
属性	OK	OK	OK	OK

	静态方法	非静态方法
静态变量	OK	OK
非静态变量	NO	OK

静态类的内存情况
类和main方法放在方法区里；创建对象时，对象one and two在栈里；通过new的形式在堆里申请空间，对各个成员变量赋值【这里是直接赋值，其他情况下是先初始化，再通过地址找到堆进行赋值】
根据类名称访问的静态成员变量的时候，全程和对象没有关系，只和类有关系。
在这里插入图片描述
静态代码块
静态代码块的格式：
public class 类名称{
static{
//静态代码块的具体内容
}
}
特点：当第一次用到本类时，静态代码执行唯一的一次。而且静态内容总是优先与非静态，所以静态代码块比构造方法先执行。
典型用途用来一次性地对静态成员变量进行赋值。

     package cn.itcast.day01.demo04;
public class person {
    static {
        System.out.println("静态代码块执行");
    }
    public person(){
        System.out.println("构造方法执行");
    }
}


package cn.itcast.day01.demo04;
public class person {
    static {
        System.out.println("静态代码块执行");
    }
    public person(){
        System.out.println("构造方法执行");
    }
}

运行结果：

首次使用类
静态代码块执行
构造方法执行
第二次使用类
构造方法执行

Arrays类

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法；
public static String tostring(数组)：将参数数组变成字符串【默认格式：[1,2,3]】
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。
备注：

如果是数值，sort按照从小到大排序
如果是字符串，sort默认按照字母升序排序
如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持
sort必须用在数组里，才可以用Array.sort（数组）方法
举例：

import cn.itcast.day01.demo3.Array;
import java.net.SocketOption;
import java.util.Arrays;
public class Arraysdemo {
    public static void main(String[] args) {
        int[] a={3,5,10,1,7,2,9};
        String str=Arrays.toString(a);
        System.out.println(str);
        System.out.println("**********开始排序***********************");
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        String[] str1={"aaa","ccc","eee","bbb"};
        Arrays.sort(str1);
        System.out.println(Arrays.toString(str1));
    }
}

练习：
键盘随机输入一行字符串，按升序打印，并倒序打印。

  public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        System.out.println("please input string");
        String str= scan.next();
       char[] c=str.toCharArray();
        Arrays.sort(c);//只有数组才可以Array.sort方法
        //System.out.println("*******"+Arrays.toString(c));

        for (int i = c.length-1; i >=0; i--) {
           System.out.println(c[i]);
        }
    }
}

Math类

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
public static double abs（double num）:获取绝对值，有多种重载。
public static double ceil（double num）：向上取整。
public static double floor（double num）：向下取整
public static double round（double num）：四舍五入

package cn.itcast.day01.demo05;
public class Mathdemo {
    public static void main(String[] args) {
        System.out.println(Math.abs(-12.65));
        System.out.println(Math.ceil(12.65));
        System.out.println(Math.floor(12.65));
        System.out.println(Math.round(12.65));
        System.out.println(Math.PI);
    }
}

运行结果

12.65
13.0
12.0
13
3.141592653589793

题目：计算-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
实现代码：

package cn.itcast.day01.demo05;
public class MathCount {
    public static void main(String[] args) {
        int count=0;
        double[] a=new double[100];
        for(double i=Math.ceil(-10.8);i<= Math.floor(5.9);i++){
            if (Math.abs(i)>6||Math.abs(i)<2.1)
            {    a[count]=i;
            System.out.print(a[count]+"->");
            count++;}
        }
        System.out.println("一共是："+count);
    }
}

运行结果：

-10.0->-9.0->-8.0->-7.0->-2.0->-1.0->0.0->1.0->2.0->一共是：9

Y动动

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java常用的API（应用程序编译接口）

文章目录常用的API（应用程序编译接口）Sacnner类匿名对象random类常用的API（应用程序编译接口）Sacnner类步骤导包（import 包路径.类名称）【如果使用的类和当前类在同一个包，可以省略这一步】创建使用Sacnner例子匿名对象创建对象的标准格式类名称对象名=new 类名称();匿名对象的创建new 类名称(); 注意事项：只能使用唯一的一次，下次再用在创建一个新的对象；建议使用：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象举例标准的格
复制链接

扫一扫