黑马全套Java教程（三）-CFANZ编程社区

文章目录

14 面向对象基础

14.1 类和对象
14.2 类的定义
14.3 对象的使用
14.4 成员变量和局部变量
14.5 封装

1. private关键字
2. this关键字

14.6 构造方法
14.7 标准类的制作

15 字符串

15.1 API
15.2 帮助文档的使用
15.3 API使用练习
15.5 String
15.6 字符串的比较
15.7 String中的方法
15.8 StringBuilder
15.9 StringBuilder和String的相互转换

16 集合

16.1 ArrayList
16.2 ArrayList构造方法和添加方法
16.3 ArrayList集合常用方法

本博客配套黑马教学视频，视频请查看B站，本博客从第99个视频开始，第99集视频链接

前面的视频配套博客如下：
黑马全套Java教程（一）黑马全套Java教程（二）

14 面向对象基础

14.1 类和对象

什么是对象？
客观存在的事物，都可称为对象！万物皆对象

什么是类？
类是对现实生活中一类具有共同属性和行为的事物的抽象

类的特点：

类是对象的数据类型
类是具有相同属性和行为的一组对象的集合

什么是对象的属性？
属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值

什么是对象的行为？
行为：对象能够执行的操作

类和对象的关系

类：类是对现实生活中一类具有共同属性和行为的事物的抽象

对象：是能够看得到摸得着的真实存在的实体

黑马全套Java教程（三）_Java

14.2 类的定义

类是对现实生活中一类具有共同属性和行为的事物的抽象

类的组成：属性和行为

属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤如下：

黑马全套Java教程（三）_Java_02

代码实现如下：

package myClass;

/*
    类的定义

    类的定义步骤：
        定义类
        编写类的成员变量
        编写类的成员方法

    手机类
        类名：
        手机（phone）

        成员变量：
        品牌（brand）
        价格（price）

        成员方法：
        打电话（call）
        发短信（sendMessage）
 */

public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
}

14.3 对象的使用

黑马全套Java教程（三）_构造方法_03

代码实现如下：

package myClass;

/*
    创建对象
        格式： 类名 对象名 = new 类名();
        范例： Phone p = new Phone();

    使用对象
        1.使用成员变量
            格式：对象名.变量名
            范例：p.call()
 */

public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);   //null   有默认值
        System.out.println(p.price);   //0
        System.out.println("-----------------");
        p.brand = "小米";
        p.price = 2999;
        System.out.println(p.brand);
        System.out.println(p.price);
        System.out.println("-----------------");

        //成员方法的使用
        p.call();
        p.sendMessage();
    }
}

案例：定义学生类，然后定义学生测试类，在测试类中完成对成员变量和成员方法的使用
Student.java

package myClass;
/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void study(){
        System.out.println("好好学习，天天向上！");
    }
    public void doHomework(){
        System.out.println("键盘敲烂，月薪过万！");
    }
}

StudentDemo.java

package myClass;
/*
    学生测试类
 */

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println("s:" + s);

        //使用对象
        System.out.println(s.name + "," + s.age);
        s.name = "林青霞";
        s.age = 30;
        System.out.println(s.name + "," + s.age);

        s.study();
        s.doHomework();
    }
}

黑马全套Java教程（三）_构造方法_04

多个对象内存图

黑马全套Java教程（三）_构造方法_05

代码实现如下：

package myClass;

public class StudentTest02 {
    public static void main(String[] args) {
        //创建第一个对象并使用
        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        System.out.println("s1" + s1);
        System.out.println(s1.name + "," + s1.age);
        s1.study();
        s1.doHomework();
        System.out.println("-----------------");

        //创建第二个对象
        Student s2 = new Student();
        s2.name="张曼玉";
        s2.age=28;
        System.out.println("s2" + s2);
        System.out.println(s2.name + "," + s2.age);
        s2.study();
        s2.doHomework();
    }
}

黑马全套Java教程（三）_System_06

多个对象指向相同时的内存图

黑马全套Java教程（三）_Java_07

代码实现：

package myClass;
/*
    多个对象指向相同
 */
public class StduentTest03 {
    public static void main(String[] args) {
        //创建爱你第一个对象并使用
        Student s1 = new Student();

        s1.name = "林青霞";
        s1.age = 30;
        System.out.println("s1" + s1);
        System.out.println(s1.name + "," + s1.age);
        System.out.println("--------------");

        //把第一个对象的地址赋值给第二个对象
        Student s2 = s1;
        s2.name = "张曼玉";
        s2.age = 28;
        System.out.println("s2" + s2);
        System.out.println(s2.name + "," + s2.age);
    }
}

黑马全套Java教程（三）_Java_08

注意，这里修改s2会改变s1

14.4 成员变量和局部变量

什么是成员变量和局部变量

黑马全套Java教程（三）_System_09

区别如下：

黑马全套Java教程（三）_构造方法_10

14.5 封装

为什么要封装?
有些机密的东西不能直接展示出来，可以进行封装

1. private关键字

private关键字

是一个权限修饰符
可以修饰成员（成员变量和成员方法）
作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供响应的操作

提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

例：这里用private封装年龄
Student.java

package myClass2;

/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    //int age;
    private int age;

    //提供get/set方法
    public void setAge(int a){
        age = a;
        if (a<0 || a>120){
            System.out.println("你给的年龄有误！");
        }
        else{
            age = a;
        }
    }
    public int getAge(){
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package myClass2;
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //给成员变量赋值
        s.name = "林青霞";
        //s.age = 30;

        //s.setAge(30);
        s.setAge(-30);

        //调用方法
        s.show();
    }
}

黑马全套Java教程（三）_字符串_11

2. this关键字

黑马全套Java教程（三）_System_12

上面是用a表示age，为了命名规范，这里用this.age比a好得多

代码实现：
Student.java

package myClass03;

/*
    学生类
 */

public class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String name){
        //name = name;
        this.name = name;    //相当于Python的self
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }

    public void show(){
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package myClass03;

import org.w3c.dom.ls.LSOutput;

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        //使用get方法获取成员变量的值
        //System.out.println(s.getName() + "---" + s.getAge());
    }
}

黑马全套Java教程（三）_System_13

封装总结：
1.封装概述
是面向对象三大特征之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

2.封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的setXxx()和getXxx()方法。

3.封装的好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

14.6 构造方法

功能：主要是完成对象数据的初始化

注意事项

如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载

如果自定义了带参数构造方法，还使用无参数构造方法，就必须再写一个无参数构造方法

推荐方式

无论是否使用，都手工写一个无参数构造方法

黑马全套Java教程（三）_字符串_14

代码实现如下：

Student.java

package myClass04;

/*
    学生类

    构造方法：
        作用：创建对象
        功能：完成对象数据的初始化

    格式：
        修饰符 类名(参数){}

        修饰符一般用：public
 */

public class Student {
    private String name;
    private int age;

    //构造方法
//    public Student(){
//        System.out.println("无参构造方法");
//    }

    //构造方法的重载：构造方法可以给定参数赋值
    public Student(){}   //无参构造方法
    public Student(String name){
        this.name = name;
    }
    public Student(int age){
        this.age = age;
    }
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void show(){
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package myClass04;

/*
    测试类
 */

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
        System.out.println("-----------------");

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();
        System.out.println("-----------------");

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();
        System.out.println("------------------");

        //public Student(String name, int age)
        Student s4 = new Student("林青霞", 30);
        s4.show();
    }
}

14.7 标准类的制作

黑马全套Java教程（三）_System_15

代码实现如下

Student.java

package myClass05;
/*
    成员变量
        使用private修饰

    构造方法
        提供一个无参构造方法
        提供一个带多个参数的构造方法

    成员方法
        提供每一个成员变量对应的setXxx()/getXxx()
        提供一个显示对象信息的show()
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student(){}

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    //成员方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age= age;
    }
    public int getAge(){
        return age;
    }
    public void show(){
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package myClass05;
/*
    创建对象并为其成员变量赋值的两种方法
        1.无参数构造方法创建对象后使用set赋值
        2.使用带参数构造方法直接创建带有属性值的对象
 */
public class StudentDemo {
    public static void main(String[] args) {
        //1.无参构造方法创建对象
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        //2.使用带参数的构造方法赋值
        Student s2 = new Student("林青霞", 30);
        s2.show();
    }
}

15 字符串

15.1 API

API：应用程序编程接口

黑马全套Java教程（三）_Java_16

15.2 帮助文档的使用

JAVA帮助文档：
链接：https://pan.baidu.com/s/17kKejic9P4rG5zcIg5jEtA
提取码：11l0
注：该文件包含JAVA6、8、9、10、13、14中文帮助文档

具体使用教程可查看黑马第115个视频，视频链接

15.3 API使用练习

需求：按照帮助文档的使用步骤学习Scanner 类的使用，并实现键盘录入一个字符串，最后输出在控制台

黑马全套Java教程（三）_System_17

代码：

package myString;

import java.util.Scanner;

/*
    Scanner：
        用于获取键盘录入数据

    public String nextLine()
        获取键盘录入字符串数据
 */
public class ScannerDemo {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);

        //接收数据
        System.out.println("请输入一个字符串数据：");
        //String line = sc.nextLine();
        //Ctrl + Alt + V  : 生成左边的快捷键
        String line = sc.nextLine();

        //输出结果
        System.out.println("你输入的数据是：" + line);
    }
}

15.5 String

String概述
String类在java.lang包下，所以使用的时候不需要导包
String类代表字符串，Java程序中的所有字符串文字（例如“abc”）都被实现为此类的实例；也就是说，Java程序中所有的双引号字符串，都是String类的对象

字符串的特点

字符串不可变，它们的值在创建后不能被更改
虽然String的值是不可变的，但是它们可以被共享
字符串效果上相当于字符数组（char[]），但是底层原理是字节数组（byte[]）

String构造方法

黑马全套Java教程（三）_构造方法_18

package myString;
/*
    String构造方法：
        1. public String()：创建一个空白字符串对象，不包含任何内容
        2. public String(char[] chs)：根据字符数组的内容，来创建字符串对象
        3. public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
        4. String s = "abc"   直接赋值的方法创建字符串对象，内容就是abc
 */
public class StringDemo01 {
    public static void main(String[] args) {
        //public String()：创建一个空白字符串对象
        String s1 = new String();
        System.out.println("s1:" + s1);  //输出空白内容

        //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
        byte[] bys = {97,98,99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        //String s = "abc"   直接赋值的方法创建字符串对象，内容就是abc
        String s4 = "abc";   // 这里是没有使用构造方法的
        System.out.println("s4:" + s4);
    }
}

黑马全套Java教程（三）_构造方法_19

String对象的特点

特点1

黑马全套Java教程（三）_字符串_20

特点2

黑马全套Java教程（三）_System_21

特点1内存过程：输出false

黑马全套Java教程（三）_System_22

package myString;

public class StringDemo1 {
    public static void main(String[] args) {
        //构造方法的方式得到对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs);
        System.out.println(s1==s2);
    }
}

黑马全套Java教程（三）_Java_23

特点2内存过程：输出true

黑马全套Java教程（三）_构造方法_24

代码实现比较如下：

package myString;

public class StringDemo2 {
    public static void main(String[] args) {
        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";
        System.out.println(s3==s4);
    }
}

黑马全套Java教程（三）_System_25

15.6 字符串的比较

使用==做比较

基本类型：比较的是数据值是否相同
引用类型：比较的是地址值是否相同

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫：equals()，返回值为bool类型

package myString;
/*
    使用 == 做比较
        基本类型：比较的是数据值是否相同
        引用类型：比较的是地址值是否相同

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

public class StringDemo02 {
    public static void main(String[] args) {
        //构造方法的方式得到对象
        char[] chs = {'a','b','c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";

        //比较字符串对象地址是否相同
        System.out.println(s1==s2);
        System.out.println(s2==s3);
        System.out.println(s3==s4);   //相同
        System.out.println("--------------");

        //比较字符串内容是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s3.equals(s4));
    }
}

黑马全套Java教程（三）_System_26

案例1：用户登录模拟

package myString;

import java.util.Scanner;

public class StringTest01 {
    public static void main(String[] args) {
        //已知用户名和密码，定义两个字符串表示即可
        String username = "itheima";
        String password = "czbk";

        //for循环实现多次机会
        for (int i = 0; i < 3; i++) {
            //键盘录入要登录的用户名和密码，用Scanner实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入用户名：");
            String name = sc.nextLine();

            System.out.println("请输入密码：");
            String pwd = sc.nextLine();

            //进行比较
            if (name.equals(username) && pwd.equals(password)) {
                System.out.println("登录成功");
                break;
            } else {
                if (2 - i == 0) {
                    System.out.println("你的账户被锁定，请与管理员联系");
                } else {
                    System.out.println("登录失败，你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}

案例2：遍历字符串

黑马全套Java教程（三）_System_27

package myString;

import java.util.Scanner;

public class StringTest02 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用Scanner实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //遍历字符串，首先要能够获取到字符串的每一个字符
        //length()方法获取字符串长度
        for (int i = 0; i < line.length(); i++) {
            System.out.println(line.charAt(i));
        }
    }
}

黑马全套Java教程（三）_字符串_28

案例3：统计字符次数

黑马全套Java教程（三）_构造方法_29

package myString;

import java.util.Scanner;

public class StringTest03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入字符串：");
        String line = sc.nextLine();

        int DaXie = 0;
        int XiaoXie = 0;
        int ZiMu = 0;

        for (int i = 0; i < line.length(); i++) {
            char ch = line.charAt(i);
            if (ch >= 'A' && ch <= 'Z') {
                DaXie += 1;
            } else if (ch >= 'a' && ch <= 'z') {
                XiaoXie += 1;
            } else if (ch >= '0' && ch <= '9') {
                ZiMu += 1;
            }
        }

        System.out.println("大写字母个数：" + DaXie);
        System.out.println("小写字母个数：" + XiaoXie);
        System.out.println("数字个数：" + ZiMu);
    }
}

黑马全套Java教程（三）_构造方法_30

案例4：拼接字符串

黑马全套Java教程（三）_System_31

package myString;

/*
    拼接字符串
 */
public class StringTest04 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        //调用方法，接收结果
        String s = arrayToString(arr);
        System.out.println("s: "+ s);
    }

    public static String arrayToString(int[] arr) {
        //在方法中遍历数组，按照要求进行拼接
        String s = "";
        s += "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                s += arr[i];
            } else {
                s += arr[i];
                s += ", ";
            }
        }
        s += "]";
        return s;
    }
}

黑马全套Java教程（三）_字符串_32

案例5：字符串反转

黑马全套Java教程（三）_Java_33

package myString;

import java.util.Scanner;

/*
    字符串反转
 */
public class StringTest05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        String sReverse = StringToReverse(s);
        System.out.println("反转后：" + sReverse);
    }

    public static String StringToReverse(String s) {
        String ss = "";
        for (int i = s.length() - 1; i >= 0; i--) {
            ss += s.charAt(i);
        }
        return ss;
    }
}

黑马全套Java教程（三）_System_34

15.7 String中的方法

常见方法

黑马全套Java教程（三）_构造方法_35

可在帮助文档中查看到：

黑马全套Java教程（三）_Java_36

黑马全套Java教程（三）_System_37

黑马全套Java教程（三）_字符串_38

字符串中的方法比较多！

15.8 StringBuilder

String内存过程：我们知道字符串是不可变的，常量

黑马全套Java教程（三）_System_39

可以看到进行字符串拼接会浪费堆内存

黑马全套Java教程（三）_System_40

所以引出来了StringBuilder

StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBuilder对象中的内容是可变的

String和StringBuilder的区别？

String：内容是不可变的
StringBuilder：内容是可变的

StringBuilder构造方法

黑马全套Java教程（三）_字符串_41

例1

package myString;
/*
    StringBuilder构造方法
        public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
        public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
 */
public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //1.public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());
        System.out.println("--------------------------");

        //2.public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

黑马全套Java教程（三）_构造方法_42

StringBuilder添加和反转的方法
例：添加：.append()

package myString;

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();

        //
        StringBuilder sb2 = new StringBuilder("hello");
        StringBuilder sb3 = sb.append("hello");
        System.out.println("sb:" + sb);
        System.out.println("sb2:" + sb2);
        System.out.println("-----------------");

        System.out.println("sb==sb2:" + (sb==sb2));
        System.out.println("sb==sb3:" + (sb==sb3));
    }
}

黑马全套Java教程（三）_构造方法_43

例：反转：.reverse()

package myStringBuilder;
/*
    StringBuilder 的添加和反转方法
        public StringBuilder append(任意类型)：添加数据，并返回对象本身
        public StringBuilder reverse()：返回相反的字符序列
 */
public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();
//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);

        //链式编程
        sb.append("hello").append("world").append("java").append(100);
        System.out.println(sb);

        //反转
        sb.reverse();
        System.out.println(sb);

    }
}

黑马全套Java教程（三）_System_44

15.9 StringBuilder和String的相互转换

StringBuilder 转换为 String：toString()
String 转换为 StringBuilder：public StringBuilder(String s)：通过构造方法就可以实现

package myStringBuilder;
/*
    StringBuilder 转换为 String
        toString()

    String 转换为 StringBuilder
        public StringBuilder(String s)：通过构造方法就可以实现
 */
public class StringBuilderDemo02 {
    public static void main(String[] args) {
        //1.StringBuilder to String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
        //String s = sb;   //这个是错误做法
        String s = sb.toString();
        System.out.println(s);

        //2.String to StringBuilder
        String ss = "hello";
        //StringBuilder s = ss;  //这个是错误的
        StringBuilder sb2 = new StringBuilder(ss);
        System.out.println(sb2);
    }
}

黑马全套Java教程（三）_System_45

案例：拼接字符串

黑马全套Java教程（三）_构造方法_46

package myStringBuilder;

/*
    拼接字符串
 */
public class StringBuilderDemo03 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        String s = pinJie(arr);
        System.out.println(s);
    }

    public static String pinJie(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]);
            if (i != arr.length - 1) {
                sb.append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

案例：字符串反转

黑马全套Java教程（三）_字符串_47

package myStringBuilder;
/*
    字符串反转
 */
import java.util.Scanner;

public class StringBuilderDemo04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        String s = stringReverse(line);
        System.out.println("反转后：" + s);
    }
    public static String stringReverse(String s){
//        StringBuilder sb = new StringBuilder(s);
//        sb.reverse();
//        String ss = sb.toString();
//        return ss;

        //用一行代码实现上面功能
        return new StringBuilder(s).reverse().toString();
    }
}

黑马全套Java教程（三）_字符串_48

这些方法都能在帮助文档中找到！如下：

黑马全套Java教程（三）_System_49

黑马全套Java教程（三）_System_50

黑马全套Java教程（三）_构造方法_51

黑马全套Java教程（三）_构造方法_52

本博客到黑马视频的第133个！

16 集合

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
集合类有很多，目前只学习一个：ArrayLlist，需要导包

16.1 ArrayList

ArrayList< E>

可调整大小的数组实现
< E>：是一种特殊的数据类型，泛型

什么用呢？
在出现E的地方我们使用引用数据类型替换即可
举例：ArrayList<String>，ArrayList<Student>

16.2 ArrayList构造方法和添加方法

黑马全套Java教程（三）_Java_53

package myArrayList;

import java.util.ArrayList;
/*
    ArrayList构造方法：
        public ArrayList()：创建一个空的集合对象

    ArrayList添加方法：
        public bollean add(E e)：将指定的袁术追加到此集合的末尾
        public void add(int index, E,element)：在此集合中的指定未知插入指定的元素
 */

public class ArrayListDemo01 {
    public static void main(String[] args) {
        //public ArrayList()：创建一个空的集合对象
        //ArrayList<String> array = new ArrayList<>();
        ArrayList<String> array = new ArrayList<String>();  //这两个都行

        //add添加元素
        System.out.println(array.add("hello"));
        System.out.println(array.add("world"));
        array.add("100");

        //add指定位置添加元素
        array.add(1, "java");   //如果索引超出会报错
        array.add(4, "javaee");

        //输出集合
        System.out.println("array:" + array);
    }
}

16.3 ArrayList集合常用方法

黑马全套Java教程（三）_构造方法_54

代码举例如下：

package myArrayList;

import java.util.ArrayList;

/*
    Array常用方法：
        remove删除指定元素
        remove删除指定索引处的元素
        set修改指定索引处的元素
        get获取指定索引处的元素
        size()返回集合元素个数
 */
public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> array = new ArrayList<String>();

        //添加元素
        array.add("world");
        array.add(1, "hello");
        array.add("java");
        array.add("python");
        System.out.println("attay:" + array);

        //1.删除指定元素
        System.out.println("1.删除world：" + array.remove("world"));
        System.out.println(" 删除javaee：" + array.remove("javaee")); //没有这个,false
        System.out.println("attay1:" + array);

        //2.指定索引
        System.out.println("删除指定索引1，返回索引对应的值：" + array.remove(1));  //返回索引值的元素
        //System.out.println(array.remove(3));   //删除时索引越界会报错
        System.out.println("attay2:" + array);

        //3.修改索引对应的值
        System.out.println("修改索引1的值，返回被修改的值：" + array.set(1, "C++"));
        //注意：索引越界会报错
        System.out.println("attay3:" + array);

        //4.返回指定索引处的元素
        System.out.println("返回1索引的元素：" + array.get(1));
        System.out.println("attay4:" + array);

        //5.获取元素个数
        System.out.println("元素个数：" + array.size());
    }
}

案例：存储字符串并遍历

黑马全套Java教程（三）_构造方法_55

package myArrayList;

import java.util.ArrayList;

public class ArrayListTest01 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();

        //添加元素
        array.add("aaa");
        array.add("bbb");
        array.add("ccc");

        //遍历
        for (int i=0; i<array.size(); i++){
            String s = array.get(i);
            System.out.println(s);
        }
    }
}

案例2：存储学生对象并遍历

黑马全套Java教程（三）_Java_56

package myArrayList;

import java.util.ArrayList;

public class ArrayTest02 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<Student> array = new ArrayList<Student>();  //括号里面改了

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("风清扬", 33);
        Student s3 = new Student("张曼玉", 18);

        //添加学生对象到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //遍历
        for (int i=0; i< array.size(); i++){
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

案例3：

黑马全套Java教程（三）_构造方法_57

package myArrayList;

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayTest03 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<Student1> array = new ArrayList<Student1>();

        //键盘录入
        addStudent(array);
        addStudent(array);
        addStudent(array);

        //遍历集合
        for(int i=0; i<array.size(); i++){
            Student1 s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }

    public static void addStudent(ArrayList<Student1> array){
        //键盘录入
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();

        //创建学生对象
        Student1 s = new Student1();
        s.setName(name);
        s.setAge(age);

        //往集合中添加学生对象
        array.add(s);
    }
}

此博客到视频139截止！