Java常用API

1,Scanner类

Scanner 类的功能,可以实现键盘的输入数据
1,导包
import 包路径.名称;
如果需要使用目标类,和当前类位于同一个包下的时候可以省略导包语句
只有在java.lang包下的内容不需要导包,其他的都需要导包语句
2,创建
类名称 对象名 = new 类名称();
3,使用
对象名,成员方法名();

 public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        System.out.println(str);
    }

2,匿名对象

创建对象的标准格式
类名称 对象名 = 类名称();

匿名对象:只有左边的对象,没有左边的名字和赋值运算符
new 类名称();

注意事项:匿名对象只能使用唯一的一次,下次再用不得不在创建一个新的对象;
使用建议:如果确定一个对象只是用唯一的一次。

//匿名对象
        new Person().name = "Ocean";
        new Person().showName(); //?
        //普通使用方式
//        Scanner in = new Scanner(System.in);
//        int num = in.nextInt();

        //匿名使用方式
        int num = new Scanner(System.in).nextInt();
        System.out.println("The input is " + num);

        //常规
        Scanner sc = new Scanner(System.in);
        //使用匿名对象来传参
        methodParam(new Scanner(System.in));

3,Random类

Random 类用来生成随机数、

1,导包
import java.utill.Random
2,创建
Random r = new Radom();
3,使用
获取一个int的随机数字(int所有范围,正负两种),int num = r.nextInt();
获取一个int的随机数子(参数代表了范围,左闭右开区间),int num = r.nextInt(3);
实际上代表的含义是:[); 0~2;

(1),猜数字小游戏

猜数字的小游戏

思路:
1,首先需要产生一个随机数字,并且一旦产生不再变化。用Random的next方法
2,键盘输入,用Scanner
3,获取键盘输入的数字,用Scanner的nextInt方法
4,已经得到了两个数字,判断(if)
如果太大,提示,并且重试
如果太小,提示,并且重试
如果正好,游戏结束
5,重试再来一次,循环次数不确定,用While(true)

public static void main(String[] args) {
        Random r = new Random();
        int randomNum = r.nextInt(100) + 1;
        Scanner in =new Scanner(System.in);

        System.out.println("Please input a number.");
        while(true) {
            int guessNum = in.nextInt();
            if (guessNum > randomNum) {
                System.out.println("Is so big ! Please try again.");
            }
            else if (guessNum < randomNum) {
                System.out.println("Is so small ! Please try again.");
            }
            else {
                System.out.println("you are win.");
            }
        }
    }

(2),

根据int变量n的值,来获取随机数字范围是[1,n],可以取到n,

1,定义一个变量n
2,要使用Randmo
3,如果写一个10,那麽就是09,然而想要110,所以整体+1.

public static void main(String[] args) {
        int num = 5;
        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            int result = r.nextInt(num) + 1;
            System.out.println(result);
        }
    }

4,ArrayList类

(1),

对象数组

定义一个数组来存储3个Person对象

数组有一个缺点。 一旦创建,程序的长度就无法在运行时更改。

Person[] array = new Person[3];
 System.out.println(array[0]);
Person one = new Person("James",35);
        Person two = new Person("Wade",36);
        Person three = new Person("Anthony",35);

        //Assign the address value in 1 to the 0 element of the array
        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]); //address value
        System.out.println(array[1]); //address value
        System.out.println(array[2]); //address value

(2),ArrayList的常用方法是:

public boolean add(E,e)
向集合中添加元素,参数类型与泛型一致。返回值指示添加是否成功
注意:对于所有ArrayList,add操作必须成功,因此返回值可用。
但是对于其他集合,add 添加不一定成功。

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

public E remove(int index)
从集合中删除元素,参数为索引号,返回值为删除元素。

public int size()
获取集合的长度,返回值是集合中元素的数量。

public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        
        boolean success = list.add("James");
        System.out.println(list);
        System.out.println("Whether the addition is successful:" + success);

        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        System.out.println(list);

        //Get elements from collection. get. Index value starts from zero
        String name2 = list.get(2);
        System.out.println("Second index position: " + name2);

        //Delete elements from collection. remove. Index value starts from zero
        String whoRemove = list.remove(3);
        System.out.println("Delete: " + whoRemove); // C
        System.out.println(list);

        int size = list.size();
        System.out.println("Collection length is:" + size);
    }

(3),遍历

//Traverse collection
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

(4),

如果要在数组列表中存储基本类型,则必须对基本类型使用“包装类”。
基本类型:包装器类(引用类型,包装器类位于java.lang包下)
byte Byte
short Short
int Integer special
long Long
float Float
double Double
char Character special
boolean Boolean

从JDK1.5开始,支持自动装箱,自动拆箱
自动装箱: base type --> wrapper class
自动拆箱: wrapper class --> base type

(5),数组和ArrayList的区别

数组的长度不能更改

但是ArrayList集合的长度可以自由更改。

对于ArrayList,有一个尖括号,表示通用
泛型:集合中包含的所有元素都是统一类型。
注意:泛型只能是引用类型,而不能是基本类型。

注意事项:
对于ArrayList集合,直接打印不是地址值,而是内容。
如果内容为空,则会出现方括号[]

(6),集合的应用

问题:
生成1到33之间的6个随机数,将其添加到集合中并遍历。

理念:
1,需要存储六个数字,创建一个集合,
2,生成随机数,需要使用随机数
3,使用循环六次生成6个随机数,进行循环
4,循环调用r.nextInt(int n),参数为33,0〜32,整体+1为1〜33。
5,将数字添加到收藏夹中,添加
6,遍历集合:for,size,get

public class Demo01ArrayListRandom {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 6; i++) {
            int num = r.nextInt(33);
            list.add(num);
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

(7),问题:

定义四个学生对象,添加到集合中并遍历

public class Demo02ArrayListStudent {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        Student one = new Student("James",35);
        Student two = new Student("Wade",36);
        Student three = new Student("Anthony",35);
        Student four = new Student("pual" ,30);

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

        //Traverse collection
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println("Name: " + stu.getName() + "Age: " + stu.getAge());
        }
    }

}
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;
    }
}

5,String类

(1),java.lang.String类代表String

API:Java程序中的所有字符串文字(例如“ abc”)都实现为此类的实例。
实际上,程序中所有用双引号引起来的字符串都是String类的对象(即使没有新的)

字符串的特征:
1,字符串内容不能更改
2,仅仅因为不能更改字符串,所以可以共享字符串。
3,字符串效果是一个char数组,但基本原理是Byte []字节数组。
三种创建+方法:
public String()
创建一个没有任何内容的空白字符串
public String (char[] array)
根据字符数组的内容创建相应的字符串
public String (byte[] array)
根据字节数组的内容创建一个相应的字符串
直接创建:
String str = "hello"

注意:
直接写双引号,它是一个字符串对象

public class Demo01String {
    public static void main(String[] args) {
        String str1 = new String();
        System.out.println("The first string: " + str1);
        char[] charArray = {'a', 'b', 'c', 'd'};
        String str2 = new String(charArray);
        System.out.println("The second string: " + str2);
        byte[] byteArray = {98, 97, 99};
        String str3 = new String(byteArray);
        System.out.println("The third string: " + str3);
        String str4 = "Hello";
        System.out.println(str4);

(2),字符串常量池

程序当中直接写上的双引号字符串,就在字符串常量池中。
对于基本类型来说,== 是进行数值的比较
对于引用类型来说,== 时进行地址值比较

 String Str1 = "abc";
        String Str2 = "abc";

        char[] charArray = {'a', 'b', 'c'};
        String Str3 = new String(charArray);

        System.out.println(Str1 == Str2);//true
        System.out.println(Str1 == Str3);//false
        System.out.println(Str2 == Str3);//false

(3),Equals 方法

/*
== 是进行对象地址值比较,如果确实需要字符串的内容比较,可以用两个方法。

public boolean equals(object obj) 参数是任何对象,只有参数相同的才是true,否则都是false
注意事项:
1,任何对象都可以用Object来接收,
2,equals 方法具有对称性,也就是a.equals(b)和b.equals(a)效果一样
3,如果比较双方一个常量一个变量,推荐把常量写在前面

public boolean equalsIgnoreCase(String str); 忽略大小写,
*/

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(str1.equals("hello"));//true
        System.out.println("hello".equals(str1));//true

        String str4 = "Hello";
        System.out.println(str1.equals(str4));//false
        System.out.println("===================");

        String str5 = "abc";//如果str5 = "null";
        System.out.println("abc".equals(str5));//推荐,
        System.out.println(str1.equals("abc"));//不推荐,这个就会报错。
        System.out.println("=========================");
        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB));
        System.out.println(strA.equalsIgnoreCase(strB));//只有英文字母区别大小写
    }

(4),获取方法

String 中与大小写获取相关的常用方法有:
public int Length() 获取字符出串的长度
public String concat(String str) 将当前字符串和参数字符串拼接成返回值的新字符串。
public char charAt(int dex)获取指定索引位置的单个字符。(索引从零开始)
public int indexOf(String str) 查找参数字符串在本字符串当中首次出现的索引位置,如果没有返回-1值。

String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);

//获取指定索引的单个字符
        char c = "Hello".charAt(1);
        System.out.println(c);

//查找 参数字符串在本来字符串中出现的第一次索引位置
        //如果没有就返回 -1值
        String original = "helloworld";
        int index = original.indexOf("llo");
        System.out.println(index);
        System.out.println("hello world".indexOf("abc"));

(5),substring 方法

字符串的截取方法:
public String substring(int index) 从该参数位置到结尾哦
public String substring(int begin, int end)

String str1 = "Helloworld";
        String str2 = str1.substring(5);
        System.out.println(str1);
        System.out.println(str2);
        String str3 = str1.substring(4,7);
        System.out.println(str3);

(6),String 中的转化方法有:

public char[] toCharArray(); 将当前字符串拆分成字符数组

char[] chars = "hello".toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

public byte[] getBytes(); 获取当前字符串底层的字节数组

 byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

public String replace(charSequence old String, 插入Sequence newString);

String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1);
        System.out.println(str2);

        String lang = "你大爷的!";
        String lang1 = lang.replace("你大爷的", "****");
        System.out.println(lang);
        System.out.println(lang1);

(7),分割字符串:

public String[] split(String regex) 按照参数的规则,将字符串分成若干份。
注意:
split的参数是正则表达式
今天要注意,如果按照英文句点,“进行分割,必须写"\."

String str3 = "xxx.yyy.zzz";
        String[] array3 = str3.split("\\.");
        System.out.println(array3.length);
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }

(8),练习

键盘输入一个字符串,并且统计其出现的次数
种类有,大写字母,小写字母,数字,其他

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

        int countUpper = 0;
        int countLower = 0;
        int countNumber = 0;
        int countOther = 0;

        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            if ('A' <= ch && ch <= 'Z'){
                countUpper++;
            }
            else if('a' <= ch && ch <= 'z'){
                countLower++;
            }
            else if('0' <= ch && ch <= '9'){
                countNumber++;
            }
            else{
                countOther++;
            }
        }
        System.out.println(countUpper);
        System.out.println(countLower);
        System.out.println(countNumber);
        System.out.println(countOther);
    }

6,Static静态

(1),静态变量

定义一个学生类

public class Student {
    private int id;
    private String name;
    private int age;
    static String room;
    private static int idCounter = 0;//学号计数器  每当new一个新对象id++
    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;
    }
}

如果一个成员变量使用了Static关键字,那么这个变量不再属于对象自己,而是属于所在的类,多个对象共享同一个数据。

public static void main(String[] args) {
        Student one = new Student("James",35);
        one.room = "heat";
        System.out.println("Name: " + one.getName()
                + ",Age:" + one.getAge() + ",Room:" + one.room
                + ",Id:" + one.getId());
        Student two = new Student("Wade",36);
        System.out.println("Name: " + two.getName()
                + ",Age:" + two.getAge() + ",Room:" + one.room
                + ",Id:" + two.getId());
    }

(2),静态方法

使用Static修饰成员方法,那么这就成了静态方法。静态方法不属于对象,而是属于类的。
如果没有Static关键字,那麽必须首先创建对象,然后通过对象才能使用

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

注意:
1,静态不能直接访问非静态。
原因,在内存中先有的静态内容,后有的非静态内容。
2,静态方法中不能有this
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(numStatic);
        //静态方法可以访问静态变量
        //System.out.println(num);
        //静态方法不能访问成员变量

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


public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass();//首先创建对象
        //然后才能使用,没有static的那内容
        obj.method();
        //对于静态的方法来说,可以通过对象名来进行调用,也可以直接通过类名称来调用。
        obj.methodStatic();//正确,不推荐  这种写法也会翻译成”类名称.静态方法名“
        MyClass.methodStatic();//正确,推荐
        //对于本类当中的静态方法,可以省略类名称
        myMethod();
    }

    public static void myMethod() {

        System.out.println("自己的方法");
    }
}

(3)静态代码块

public class 类名称{
static{
//静态代码块
}
}
特点:当第一次用到本类,静态代码块只执行唯一一次
静态内容优先于非静态的

静态代码块的典型用途:
用来一次性的对静态成员变量赋值。
*/

public class Person {
    static {
        System.out.println("静态代码快执行");
    }
    public Person() {
        System.out.println("构造方法执行");
    }
}


public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

7,Arrays工具类

java.util.Arrays 是一个与数组相关的工具类,里面提供了大量的静态方法,用来实现数组常见的操作。

public static String toString(数组) 将参数数组变成字符串(按照默认格式)
public static void sort(数组) 按照默认升序对数组元素进行排序

public class Demo01Arrays {
    public static void main(String[] args) {
        int[] array = {10, 20, 30};
        //将int[] 数组按照默认格式变成字符串
        String intStr = Arrays.toString(array);
        System.out.println(intStr);//[10, 20, 30]
        int[] array1 = {6, 9, 10, 4, 1, 2, 5};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));
        }

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) 四舍五入
Math.PI

public class Demo3Math {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(-2.5));
        System.out.println("=============");
        //向上取整
        System.out.println(Math.ceil(3.9));
        System.out.println(Math.ceil(2.1));
        System.out.println("=============");
        //向下取整
        System.out.println(Math.floor(3.9));
        System.out.println(Math.floor(2.1));
        System.out.println("=============");
        //四舍五入
        System.out.println(Math.round(3.9));
        System.out.println(Math.round(2.1));
        System.out.println("=============");
        System.out.println(Math.PI);
    }
}

你可能感兴趣的:(Java常用API)