知识点总结——Day07_Scanner类、Random类、ArrayList类、String类、static关键字、Arrays类、 Math类

本文链接：https://blog.youkuaiyun.com/m0_48491400/article/details/119568695

第一章 Scanner类、Random类、ArrayList类

3.4 ArrayList常用的方法（增删查）

3.5 ArrayList遍历

3.6 ArrayLIst存储基本数据类型

第二章 String类、static关键字、Arrays类、 Math类

2.5 静态代码块（给类变量进行初始化赋值）

声明：本文整理于黑马程序员的Java教学视频，仅可作为资料参考学习使用，侵权请联系删除。

【API文档下载】：JDK_API_1_6

第一章 Scanner类、Random类、ArrayList类

一、Scanner类

1.1 Scanner的定义

一个可以解析基本类型和字符串的简单文本扫描器。使用格式如下：

Scanner sc = new Scanner(System.in);//System.in表示从键盘输入的内容
int i = sc.nextInt();

1.2 引用数据类型的使用

1.2.1 导包

使用import关键字进行导包，并且必须在类的所有代码之前进行导包。【java.lang包下的所有类都不需要导入】

import 包名.类名;

1.2.2 引用数据类型的使用步骤

1）导包

import 包路径.类名称;

2）创建

类名称对象名 = new 类名称();

3）使用

对象名.成员方法名();

1.2.3 Scanner使用举例

import java.util.Scanner;

public class MyScanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建Scanner
        System.out.println("请输入一个数字：");
        int i = sc.nextInt();//获取键盘输入的数字
        System.out.println("您输入的数字是：" + i);
    }
}

二、Random类

2.1 Random的定义

用于生成伪随机数。使用格式如下：

Random r = new Random(); //创建随机数生成器
int i = r.nextInt();//括号内可限定范围值，如r.nextInt(5)表示随机生成[0,5)区间的数字

2.2 Random使用举例

创建一个随机数生成器，随机生成[0,5)区间内的一个数字，并打印输出

import java.util.Random;

public class MyRandom {
    public static void main(String[] args) {
        Random r = new Random();//创建随机数生成器
        int i = r.nextInt(5);//随机生成[0,5)区间内的一个数字
        System.out.println("随机生成的数字是：" + i);//打印输出数字
    }
}

三、ArrayList类

3.1 对象数组

使用数组来存储对象内容。示例如下：

1）创建对象类

public class MyArr {
    private String name;
    private int num;

    public MyArr() {
    }

    public MyArr(String name, int num) {
        this.name = name;
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

2）创建实现类

public class MyArrImpl {
    public static void main(String[] args) {
        //创建MyArr数组
        MyArr[] myArrs = new MyArr[3];
        //创建MyArr对象
        MyArr m1 = new MyArr("数组1",1);
        MyArr m2 = new MyArr("数组2",2);
        MyArr m3 = new MyArr("数组3",3);
        //将对象作为元素赋给数组
        myArrs[0] = m1;
        myArrs[1] = m2;
        myArrs[2] = m3;

        //遍历数组
        for (int i = 0; i < myArrs.length; i++) {
            MyArr m = myArrs[i];
            System.out.println("数组名称：" + m.getName() + ",数组编号：" + m.getNum());
        }
    }
}

3.2 ArrayList的定义

1）ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。

2）ArrayList类提供一些方法来操作内部存储的元素。

3）ArrayList 中可不断添加元素，其大小也自动增长。即无固定长度。

3.3 ArrayList使用步骤

1）导包

import java.util.ArrayList;

2）创建

ArrayList<String> list = new ArrayList<>();

3）使用

list.add(对象);

使用举例：

import java.util.ArrayList;

public class MyArrayList {
    public static void main(String[] args) {
        //创建数组
        ArrayList<String> list = new ArrayList<>();
        //创建对象
        String s1 = "zhangsan";
        String s2 = "lisi";
        String s3 = "wangwu";
        //将对象添加到数组
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //打印数组
        System.out.println(list);
    }
}

3.4 ArrayList常用的方法（增删查）

1）public boolean add(E e) ：将指定的元素添加到此集合的尾部。

2）public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。

3）public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。

4）public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

import java.util.ArrayList;

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

3.5 ArrayList遍历

//遍历输出
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

3.6 ArrayLIst存储基本数据类型

向ArrayList中存储基本数据类型，必须使用“包装类”。

基本数据类型	包装类（引用数据类型）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

自动装箱：基本类型——>包装类型

自动拆箱：包装类型——>基本类型

第二章 String类、static关键字、Arrays类、 Math类

一、String类

1.1 String类概述

String 类代表字符串，其中包括用于检查各个字符串的方法。

1.2 String类的特点

1）字符串不变：字符串的值在创建后不能被更改。

2）可共享。

3）字符串在使用效果上相当于char[]字符数组，但是底层原理是byte[]字节数组。

1.3 字符串的使用方法

1）public String() ：初始化新创建的 String对象，以使其表示空字符序列。

String s1 = new String();

2）public String(char[] array) ：通过当前参数中的字符数组来构造新的String。

char[] array = {'A','B','C'};

3）public String(byte[] array) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。

byte[] array = {1,2,3};

4）直接创建：直接将字符串内容赋值给字符串。

String s = "hello";

1.4 String的常用方法

1）判断方法

① public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。

② public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小

public class MyString {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "zhangsan";
        String s2 = "zhangsan";
        String s3 = "ZhangSan";
        // 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接收。

② equals方法具有对称性，即a.equals(b)和b.equals(a)效果是一样的。

③ 比较双方一个是变量一个是常量，则常量在前，变量在后。

2）获取功能的相关方法

① 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 MyString {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "hello";
        // int length():获取字符串的长度，其实也就是字符个数
        System.out.println(s.length());
        System.out.println("‐‐‐");
        // String concat (String str):将将指定的字符串连接到该字符串的末尾.
        String s21 = s.concat("world");
        System.out.println(s21);// helloworld
        // 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(1));
        System.out.println("‐‐‐");
        // String substring(int start,int end):从start到end截取字符串。含start，不含end。
        System.out.println(s.substring(3, 5));
    }
}

3）转换功能的方法

① public char[] toCharArray () ：将此字符串转换为新的字符数组。

② public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。

③ public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

public class MyString {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "abcde";
        // char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.print(chs[x] + " ");
        }
        System.out.println("\n‐‐‐‐‐‐‐‐‐‐‐");
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();
        for (int x = 0; x < bytes.length; x++) {
            System.out.print(bytes[x] + " ");
        }
        System.out.println("\n‐‐‐‐‐‐‐‐‐‐‐");
        // 替换字母h和w为大写H和W
        String str = "hello world";
        String replace = str.replace("h", "H");
        String replace2 = replace.replace("w", "W");
        System.out.println(replace2); // Hello World
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    }
}

4）分割功能的方法

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

public class MyString {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "a。b。c";
        String[] strArray = s.split("。"); // ["a","b","c"]
        for (int x = 0; x < strArray.length; x++) {
            System.out.print(strArray[x] + " "); // a b c
        }
    }
}

二、static关键字

2.1 static关键字概述

static关键字可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。

2.2 static关键字的定义格式

类变量：使用 static关键字修饰的成员变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
static 数据类型 变量名；

2.3 静态方法

类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

修饰符 static 返回值类型 方法名 (参数列表){ 
        //方法体
}

静态方法调用格式（被static修饰的成员可以并且建议通过类名直接访问。）

// 访问类变量 
类名.类变量名；
// 调用静态方法 
类名.静态方法名(参数)；

静态方法调用的注意事项

① 静态方法可以直接访问类变量和静态方法。

② 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

③ 静态方法中，不能使用this关键字。

④ 静态方法只能访问静态成员。

2.4 静态原理

1）是随着类的加载而加载的，且只加载一次。

2）存储于一块固定的内存区域（静态区），可以直接被类名调用。

3）它优先于对象存在，可以被所有对象共享。

2.5 静态代码块（给类变量进行初始化赋值）

定义在成员位置，使用static修饰的代码块{ }。

位置：类中方法外。

执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

public class ClassName{ 
    static { 
        // 执行语句
    } 
}

static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下去调用方法。

三、Arrays类

3.1 Arrays类的概述

Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法。

3.2 操作数组的方法

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

public class MyArrays {
    public static void main(String[] args) {
        int[] arr = {5,65,26,36,659,12,123,46,55};
        System.out.println("排序前：" + Arrays.toString(arr));
        System.out.println("-----------------");
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

tips：数组的格式化输出Arrays.toString(数组名)；

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

public class MyArrays {
    public static void main(String[] args) {
        // 定义随机的字符串
        String line = "jjhkahAGSDKjFLHAAFSJKbSfsdf";
        // 转换为字符数组
        char[] chars = line.toCharArray();
        // 升序排序
        Arrays.sort(chars);
        // 反向遍历打印
        int a = chars.length-1;
        for (int i = a;i >= 0;i--){
            System.out.print(chars[i] + " ");//s k j j j h h f f d b a S S S L K K J H G F F D A A A
        }
    }
}

四、Math类

4.1 Math类概述

Math 类包含用于执行基本数学运算的方法，如初等对数、指数、和三角函数。其所有方法均为静态方法，并且不会创建对象。

4.2 Math类的基本运算方法

1）public static double abs(double a) ：求 double 值的绝对值。

double a = Math.abs(‐1); //a的值为1 
double b = Math.abs(1); //b的值为1

2）public static double ceil(double a) ：求大于等于参数的最小的整数。

double a = Math.ceil(4.3); //a的值为 5.0 
double b = Math.ceil(‐1.3); //b的值为 ‐1.0 
double c = Math.ceil(3.1); //c的值为 4.0

3）public static double floor(double a) ：求小于等于参数最大的整数。

double a = Math.floor(1.1); //a的值为1.0 
double b = Math.floor(‐1.3); //b的值为‐2.0 
double c = Math.floor(1.1); //c的值为 1.0

4）public static long round(double a) ：求最接近参数的 long。近似于求四舍五入

long a = Math.round(1.5); //d1的值为2.0 
long b = Math.round(1.4); //d2的值为1.0