Java常用API（黑马视频笔记）

引用类型的一般使用步骤：

1. 导包
   import 包路径.类名称
   如果需要使用的目标类，与当前类在同一个包下，则可以省略导包语句不写。
   只有java.lang包下的内容不需要导包，其他的包都需要import语句。
2. 创建
   类名称 对象名=new 类名称();
3. 使用
   对象名.成员方法名()

Scanner类

功能：键盘输入，将数据从键盘输入录入到程序当中

public class Demo01Scanner {
    public static void main(String[] args) {
        //2. 创建
        Scanner sc=new Scanner(System.in);   // System.in代表从键盘进行输入
        //3. 使用
        //获取键盘输入的一个int数字：int num=sc.nextInt();
        int num=sc.nextInt();
        System.out.println("输入的int数字是"+num);
        //获取键盘输入的一个字符串：String str=sc.next();
        String str=sc.next();
        System.out.println("输入的字符串是"+str);
    }
}

练习：键盘输入三个int数字，求出其中最大值

package cn.itcast.day07.demo01;
import java.util.Scanner;

public class Demo03ScannerMax {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("依次输入三个数字：");
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();

        int temp= a>b?a:b;
        int max=temp>c?temp:c;
        System.out.println("最大值为："+max);
    }
}

输出结果：

匿名对象

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

匿名对象：只有右边的对象，没有左侧的对象名和赋值运算符
new 类名称();
匿名对象只能使用唯一的一次，下次使用必须再创建一个新对象
使用建议：如果确定有一个对象，确定只使用唯一的一次，可使用匿名对象

public class Demo01Anonymous {
    public static void main(String[] args) {
       //使用匿名对象
        new Person().name="赵又廷";
        new Person().showName();   
    }
}
public class Person {
    String name;
    public void showName(){
        System.out.println("我叫："+name);
    }
}

输出结果：相当于new了两个对象，第一个对象.name，并没有赋值给第二个对象

使用匿名对象作为方法的参数

package cn.itcast.day07.demo02;
import java.util.Scanner;

public class Demo02Anonymous {
    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));
    }
    public static void methodParam(Scanner sc){
        int num = sc.nextInt();
        System.out.println("输入的是："+num);
    }

使用匿名对象作为方法的返回值

package cn.itcast.day07.demo02;
import java.util.Scanner;

public class Demo02Anonymous {
    public static void main(String[] args) {
        Scanner sc = methodReturn();
        int num=sc.nextInt();
        System.out.println("输入的是："+num);
    }
    //使用匿名对象作为返回值
    public static Scanner methodReturn(){
        //一般写法
        //Scanner sc=new Scanner(System.in);
        //return sc;
        return new Scanner(System.in);
    }
}

Random类

Random类作用：生成随机数字

使用：

1. 导包 import java.util.Random
2. 创建 Random r=new Random();
3. 使用
   获取一个随机的int数字(范围是int所有范围，有正负两种)：int num=r.nextInt();
   获取一个随机的int数字(参数代表了范围，左闭右开区间)：int num=r.nextInt(3); //指[0,3)

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

package cn.itcast.day07.demo03;

import java.util.Random;

/* 题目：根据int变量n的值，来获取随机数字，范围是[1,n] */

public class Demo03Random {
    public static void main(String[] args) {
        int n=5;
        Random r=new Random();
        for (int i = 0; i < 100; i++) {
            //原本范围是[0,n)，整体＋1后变成[1,n+1)，也就是[1,n]
            int result=r.nextInt(n)+1;
            System.out.println(result);
        }
    }
}

练习2：用代码模拟猜数字的小游戏

package cn.itcast.day07.demo03;

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

/*  
题目：用代码模拟猜数字的小游戏
思路：
1. 首先产生一个随机数字，一旦产生不再变化，用Random.nextInt()方法
2. 需要键盘输入，所以使用Scanner
3. 获取键盘输入的数据，用Scanner.nextInt()方法
4. 对获取的两个数字进行判断（if）
    如果太大，提示太大，并重试
    如果太小，提示太小，并重试
    如果猜中了，游戏结束
5. 重试即循环，循环次数不确定，用while(true)
*/
public class Demo04RandomGame {
    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("游戏结束！");
    }
}

ArrayList集合

• 任何数据类型都可以作为数组当中元素的类型。但数组的长度不可以发生改变
  ArrayList集合的长度是可以随意变化的

• ArrayList< E >，其中< E >代表泛型。即装在集合里的所有元素，都是统一的某一类型，泛型只能是引用类型，不能是基本类型（集合里保存的都是地址值，基本类型数据没有地址值）

若希望想集合存储基本类型数据，必须使用基本类型对应的“包装类”

基本类型	包装类（引用类型，包装类都位于java.lang）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

从JDK 1.5+开始，支持自动装箱、自动拆箱
自动装箱：基本类型自动变成包装类型
自动拆箱：包装类型自动拆为基本类型

• 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
  如果内容为空，得到的是空的中括号[ ]

public class Demo01ArrayList {
    public static void main(String[] args) {
        //创建了一个ArrayList集合，集合的名称是list，里面装的全是String字符串类型的数据
        //备注：从jdk1.7+开始，右侧<>内部可不写内容，但<>本身还是要写的
        ArrayList<String> list=new ArrayList<>();
        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():获取集合的尺寸长度，返回值是集合中包含的元素个数

package cn.itcast.day07.demo04;
import java.util.ArrayList;

public class Demo03ArrayListMethod {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        System.out.println(list);
        
        //向集合中添加元素
        boolean success=list.add("刘一");
        System.out.println(list);      //[刘一]
        System.out.println("添加的动作是否成功："+success);
        list.add("王二");
        list.add("张三");
        list.add("李四");
        System.out.println(list);      //[刘一, 王二, 张三, 李四]

        //从集合中获取元素，get，索引值从0开始
        String name=list.get(2);
        System.out.println("第2号索引位置："+name);

        //从集合中删除元素，remove，索引值从0开始
        String whoRemoved = list.remove(2);
        System.out.println("被删除的人是："+whoRemoved);
        System.out.println(list);
		
		//获取集合长度
        int size=list.size();
        System.out.println("集合的长度是："+size);
    }
}

输出：

遍历集合：

package cn.itcast.day07.demo04;
import java.util.ArrayList;

public class Demo04ArrayListEach {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马尔扎哈");
        //遍历集合
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

练习1：

package cn.itcast.day07.demo05;
import java.util.ArrayList;
/*
题目：自定义4个学生对象，添加到集合，并遍历
思路：
1. 自定义学生类Student，四个部分
2. 创建集合存储学生对象，泛型，<Student>
3. 根据类，创建4个学生对象
4. 将4个学生对象添加到集合中，add
5. 遍历集合，for,size,get
*/
public class Demo01ArrayListStudent {
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        Student one=new Student("刘一",20);
        Student two=new Student("王二",21);
        Student three=new Student("张三",22);
        Student four=new Student("李四",23);
        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
            Student stu=list.get(i);
            System.out.println("姓名："+stu.getName()+"，年龄："+stu.getAge());
        }
    }
}

练习2：

package cn.itcast.day07.demo05;
import java.util.ArrayList;
/*
题目：定义以指定格式打印集合的方法（ArrayList类型作为参数），使用{}括起来，使用@分隔每个元素
格式参照：{元素@元素@元素}
*/
public class Demo03ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("刘一");
        list.add("王二");
        list.add("张三");
        list.add("李四");
        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.println(name+"}");
            }else {
                System.out.print(name+"@");
            }
        }
    }
}

练习3：集合无论做参数还是返回值，传递和接受的都是地址值

package cn.itcast.day07.demo05;
import java.util.ArrayList;
import java.util.Random;
/*
题目：用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中
要求：用自定义的方法实现元素的筛选
思路：
1. 需要创建一个集合，用来存储int数字，<Integer>
2. 随机数字，Random.nextInt()
3. 循环20次，把随机数字存入大集合，for循环，add方法
4. 自定义方法，筛选元素
*/
public class Demo04ArrayListReturn {
    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;  //1-100
            bigList.add(num);
        }
        ArrayList<Integer> result=getSmallList(bigList);
        System.out.println(result);
        System.out.println("偶数一共有多少个："+result.size());
    }
    //接受大集合参数，返回小集合结果
    //集合无论做参数还是返回值，传递和接受的都是地址值
    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;
    }
}

String类

Java程序中所有字符串字面值（如"abc"）都作为此类的实例实现。
即，程序当中所有的双引号字符串，都是String类的对象，即使没有new

字符串特点：

1. 字符串是常量，它们的值在创建后不能更改
2. 因为字符串不可改变，所以字符串是可以共享使用的
3. 字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组

创建字符串的3+1种常见方式：
三种构造方法：
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("第一个字符串:"+str1);

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

        //根据字节数组创建字符串
        byte[] byteArrays={97,98,99};
        String str3=new String(byteArrays);
        System.out.println("第三个字符串："+str3);

        //直接创建
        String str4="Hello";
        System.out.println("第四个字符串："+str4);
    }
}
//输出结果为：
//第一个字符串:
//第二个字符串：ABC
//第三个字符串：abc
//第四个字符串：Hello

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

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

public class Demo01StringPool {
    public static void main(String[] args) {
        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
    }
}

上述程序的内存图如下：

//下述代码中，字符串的内容是没有改变的，其实是产生了两个字符串“Hello”和“Java”
//str1 中起初保存的是“Hello”的地址值，后来变成了“Java”的地址值
public class DemoString {
	public static void main(String[] args) {
		String str1 = "Hello";
		System.out.println(str1); //Hello
		str1 = "Java";
		System.out.println(str2); //Java
	}
}

字符串的常用方法

1. 字符串的内容比较：
   public boolean equals(Object obj):只有参数是一个字符串且内容相同（严格区分大小写）时返回 true，否则返回false
   public boolean equalsIgnoreCase(String str):忽略大小写，进行内容比较

   注意：equals() 方法具有对称性，a.equals(b) 和 b.equals(a) 效果相同。但如果比较双方一个常量一个变量，推荐将常量字符串写在前面
   推荐："abc".equals(str);" 不推荐：str.equals("abc");

   //原因：若字符串对象为空时
   String str = null;
   System.out.println("abc".equals(str)); //推荐写法，会返回false
   System.out.println(str.equals("abc"); //不推荐写法，会报错：空指针异常NullPointerException
   

2. 字符串的内容获取
   public int length():获取字符串的长度
   public String concat(): 将当前字符串与参数字符串拼接成新的字符串并返回
   public char charAt(int index):获取指定索引位置的单个字符（索引从0开始）
   public int indexOf(String str):查找参数字符串在本字符串中首次出现的索引位置，没有则返回-1

3. 字符串的截取
   public String substring(int index):截取从参数位置一直到字符串末尾，返回新的字符串
   public String substring(int begin, int end):截取从 begin 开始，一直到 end 结束中间的字符串。[begin, end)，包含 begin，不包含 end

4. 字符串的转换
   public char[] toCharArray()：将当前字符串拆分为字符数组并返回
   public byte[] getBytes()：获取当前字符串底层的字节数组
   public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换为新字符串，并返回替换后的新字符串结果 。（CharSequence是说可以接受字符串类型。CharSequence是一个接口，实现了这个接口的类有：CharBuffer、String、StringBuffer、StringBuilder这个四个类。）

public class Demo01StringConvert {
    public static void main(String[] args) {
        //转换成字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);   //97  98  99
        }
        //字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");
        System.out.println(str1);   //How do you do?
        System.out.println(str2);   //H*w d* y*u d*?
    }
}

5. 字符串的分隔
   public String[] split(String regex)：按照参数的规则，将字符串分割为若干部分
   注意：split 方法的参数其实是一个正则表达式

public class Demo01StringSplit {
    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]);  //aaa  bbb   ccc
        }
        
        String str2 = "aaa.bbb.ccc";
        String[] array2 = str2.split(".");	//根据"."分隔失败，非正则表达式
        System.out.println(((String[]) array2).length); //0
        String[] array3 = str2.split("\\.");	//采用正则表达进行分隔
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);  //aaa  bbb  ccc
        }
    }
}

练习一：

/*
* 定义一个方法，将数组[1，2，3]按照指定格式拼接成一个字符串。指定格式为：[word1#word2#word3]
*/
public class Demo01StringPractise {

    public static void main(String[] args) {
        int[] array = {1,2,3};
        String result = fromArrayToString(array);
        System.out.println(result);
    }
    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;
    }
}

练习二：

/*
* 题目：键盘输入一个字符串，统计字符串中各种字符出现的次数
* 类型包括：大写字母，小写字母，数字，其他
* */
public class Demo01StringCount {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.next();

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

静态static关键字

static关键字概述：一旦用了static关键字修饰，所修饰的内容不再属于对象自己，而是属于类，凡是本类的对象都共享同一份

static 修饰成员变量
如果一个成员变量使用了static关键字，则这个变量不属于对象本身，而是属于所在类，多个对象共享同一个数据

public class Student {
    private String name;
    private  int age;
    static String room;
    private int id;	//学号
    private static int idCounter = 0;	//学号计数器
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }
    public Student(){
        idCounter++;
    }
    public int getId() { return id;}
    public void setId(int id) { this.id = id;}
	public void setName(String name) { this.name = name;}
	public void setAge(int age) { this.age = age;}
    public String getName() { return name;}
    public int getAge() { return age;}
}

public class Demo01StaticField {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",18);
        stu1.room = "101";	//对静态成员变量赋值
        System.out.println("姓名："+ stu1.getName() + "，年龄：" + stu1.getAge() + "，教室：" + stu1.room + "，学号：" + stu1.getId());
        Student stu2 = new Student("李四",20);
        System.out.println("姓名："+ stu2.getName() + "，年龄：" + stu2.getAge() + "，教室：" + stu2.room + "，学号：" + stu2.getId());
    }
}
//Output:
//姓名：张三，年龄：18，教室：101，学号：1
//姓名：李四，年龄：20，教室：101，学号：2

static 修饰成员方法
一旦使用 static 修饰成员方法，则该方法为静态方法，属于类本身，而不属于对象
对于静态方法，可以直接通过类名调用，也可以通过对象名调用（不推荐）
没有 static 修饰的非静态方法，必须首先创建对象，才能通过对象使用它

public class MyClass {
    public void method() {
        System.out.println("这是一个普通方法");
    }
    public static void methodStatic() {
        System.out.println("这是一个静态方法");
    }
}
public class Demo01StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.method();   //非静态方法
        obj.methodStatic(); //静态方法，但不推荐。这种写法在编译后也会被javac翻译为"类名.静态方法名"
        MyClass.methodStatic(); //静态方法，推荐使用
        myMethod();
    }
    public static void myMethod(){
        System.out.println("自己的方法！");
    }
}

无论是静态成员变量还是静态成员方法，都推荐使用类名调用
类名称.静态变量
类名称.静态方法()
对于本类当中的静态方法，可以省略类名称

注意：

• 静态不能直接访问非静态（原因：在内存当中，先有的静态内容，后有的非静态内容）
• 静态方法当中不能用this关键字（原因：this代表当前对象）

public class MyClass {
    int num;
    static int myStatic;

    public void method() {
        System.out.println("这是一个普通方法");

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

        //静态方法不能访问非静态变量
        //System.out.println(num);

        //静态方法可以访问静态变量
        System.out.println(myStatic);

    }
}

静态 static 的内存图如下：

静态代码块
静态代码块的典型用途：用来一次性对静态成员变量进行赋值

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

在第一次执用到本类时，静态代码块执行唯一的一次
静态内容总是优先于非静态。

public class Person {
	static {
		System.out.println("静态代码块执行");
	}
	public Person() {
		System.out.println("构造方法执行");
	}	
}
public class Demo01Static {
    public static void main(String[] args) {
    	Person one = new Person();
    	Person two = new Person();
    }
}
//Output:
//静态代码块执行
//构造方法执行
//构造方法执行

数据工具类Arrays

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

1. public static String toString(数组)：将参数数组变为字符串（按照默认格式：[元素1，元素2，元素3…]）
2. public static void sort(数组)：按照默认升序（从小到大）对数组元素进行排序

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

        int[] array2 = {4,6,2,9,5,1};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));    //[1, 2, 4, 5, 6, 9]

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

• 如果是数值，sort默认按照升序从小到大
• 如果是字符串，sort默认按照字母升序
• 如果是自定义类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

数学工具类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 Demo03Math {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.14)); //3.14
        System.out.println(Math.abs(-4.2)); //4.2
        //向上取整
        System.out.println(Math.ceil(3.43)); //4.0
        //向下取整
        System.out.println(Math.floor(-5.64));   //-6.0
        //四舍五入
        System.out.println(Math.round(6.34));   //6
        System.out.println(Math.round(-5.67));  //-6
    }
}