Java基础（二）

校生兄

于 2021-06-15 21:59:43 发布

阅读量254

点赞数

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

本文链接：https://blog.csdn.net/qq2835483738/article/details/117933106

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文深入解读了Java中的面向对象思想，介绍了类与对象的概念，类的定义、创建和使用，以及封装的原理和实践。通过实例说明了如何创建类、对象，以及如何利用封装保护数据。还涵盖了ArrayList类和String类的基础操作，展示了面向对象编程的核心概念在实际中的应用。

摘要由CSDN通过智能技术生成

第十三章面向对象思想

13.1 面向对象思想概述

概述

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

举例

洗衣服:

面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
面向对象：把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来

区别:

面向过程：强调步骤。
面向对象：强调对象，这里的对象就是洗衣机。

特点

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。

面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

13.2 类和对象

环顾周围，你会发现很多对象，比如桌子，椅子，同学，老师等。桌椅属于办公用品，师生都是人类。那么什么是

类呢？什么是对象呢？

什么是类

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该

类事物。

现实中，描述一类事物：

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

举例：小猫。

属性：名字、体重、年龄、颜色。

行为：走、跑、叫。

什么是对象

对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。现实中，一类事物的一个实例：一只小猫。

举例：一只小猫。

属性：tom、5kg、2 years、yellow。

行为：溜墙根走、蹦跶的跑、喵喵叫。

类与对象的关系

类是对一类事物的描述，是抽象的。
对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tkSN4Bav-1623761857358)(images/image- 在这里插入图片描述
.png)]

13.3 类的定义

事物与类的对比

现实世界的一类事物：

属性：事物的状态信息。

行为：事物能够做什么。

Java中用class描述事物也是如此：

成员变量：对应事物的属性

成员方法：对应事物的行为

类的定义格式

public class ClassName { 
//成员变量 
//成员方法 
}

定义类：就是定义类的成员，包括成员变量和成员方法。
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细

讲解。

类的定义格式举例：

public class Student { 
    //成员变量 
    String name；//姓名 
    int age；//年龄
    //成员方法 
     //学习的方法 
     publicvoid study() { 
        System.out.println("好好学习，天天向上"); 
    }
    //吃饭的方法 
    publicvoid eat() { 
        System.out.println("学习饿了要吃饭"); 
    } 
}

13.4 对象的使用

创建对象：

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

使用对象访问类中的成员:

对象名.成员变量；

对象名.成员方法()；

对象的使用格式举例:

public class Test01_Student { 
    public static void main(String[] args) { 
        //创建对象格式：类名 对象名 = new 类名(); 
        Student s = new Student(); 
        System.out.println("s:"+s); //cn.itcast.Student@100363 
        //直接输出成员变量值 
        System.out.println("姓名："+s.name); //null 
        System.out.println("年龄："+s.age); //0 
        System.out.println("‐‐‐‐‐‐‐‐‐‐"); 
        //给成员变量赋值 
        s.name = "赵丽颖"; 
        s.age = 18; 
        //再次输出成员变量的值 
        System.out.println("姓名："+s.name); //赵丽颖 
        System.out.println("年龄："+s.age); //18 
        System.out.println("‐‐‐‐‐‐‐‐‐‐"); 
        //调用成员方法 
        s.study(); // "好好学习，天天向上" 
        s.eat(); // "学习饿了要吃饭" 
    }
}

成员变量的默认值

	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（flfloat，double）	0.0
	字符（char）	‘\u0000’
	布尔（boolean）	false
引用类型	数组，类，接口	null

13.5 类与对象的练习

定义手机类：

public class Phone { 
    // 成员变量 
    String brand; //品牌 
    int price; //价格 
    String color; //颜色 
    // 成员方法 
    //打电话 
    public void call(String name) { 
        System.out.println("给"+name+"打电话"); 
    }
    //发短信 
    public void sendMessage() { 
        System.out.println("群发短信"); 
    } 
}

定义测试类：

public class Test02Phone { 
    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.color);//null 
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
        //给成员变量赋值 
        p.brand = "锤子"; 
        p.price = 2999; 
        p.color = "棕色"; 
        //再次输出成员变量值 
        System.out.println("品牌："+p.brand);//锤子 
        System.out.println("价格："+p.price);//2999 
        System.out.println("颜色："+p.color);//棕色 
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐"); 
        //调用成员方法 
        p.call("紫霞"); 
        p.sendMessage(); 
    } 
}

13.6 对象内存图

一个对象，调用一个方法内存图

在这里插入图片描述

通过上图，我们可以理解，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中的空间，寻找方法信息，去执行该方法。

但是，这里依然有问题存在。创建多个对象时，如果每个对象内部都保存一份方法信息，这就非常浪费内存了，因为所有对象的方法信息都是一样的。那么如何解决这个问题呢？请看如下图解。

两个对象，调用同一方法内存图
在这里插入图片描述

对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息只保存一份，节约内存空间。

一个引用，作为参数传递到方法中内存图
在这里插入图片描述

引用类型作为参数，传递的是地址值。

13.7 成员变量和局部变量区别

变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：

在这里插入图片描述

在类中的位置不同重点
- 成员变量：类中，方法外
- 局部变量：方法中或者方法声明上(形式参数)
作用范围不一样重点
- 成员变量：类中
- 局部变量：方法中
初始化值的不同重点
- 成员变量：有默认值
- 局部变量：没有默认值。必须先定义，赋值，最后使用
在内存中的位置不同了解
- 成员变量：堆内存
- 局部变量：栈内存
生命周期不同了解
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

第十四章封装

14.1 封装概述

概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

14.2 封装的步骤

使用 private 关键字来修饰成员变量。
对需要访问的成员变量，提供对应的一对 getXxx方法、setXxx方法。

14.3 封装的操作——private关键字

private的含义

private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

private 数据类型 变量名;

使用 private 修饰成员变量，代码如下:

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

提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：

public class Student { 
    private String name; 
    private int age; 
    public void setName(String n) { 
        name = n; 
    }
    public String getName() { 
        return name; 
    }
    public void setAge(int a) { 
        age = a; 
    }
    public int getAge() { 
        return age; 
    } 
}

14.4 封装优化1——this关键字

我们发现 setXxx 方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？代码如下：

public class Student { 
    private String name; 
    private int age; 
    public void setName(String name) { 
        name = name; 
    }
    public void setAge(int age) { 
        age = age; 
    } 
}

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了 setXxx() 的形参变量名后，方法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。

this的含义

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

记住：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

this使用格式

this.成员变量名;

使用 this 修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：

public class Student { 
    private String name; 
    private int age; 
    public void setName(String name) { 
        //name = name; 
        this.name = name; 
    }
    public String getName() { 
        return name; 
    }
    public void setAge(int age) { 
        //age = age; 
        this.age = age; 
    }
    public int getAge() { 
        return age;
    } 
 }

14.5 封装优化2——构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

小贴士：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

构造方法的定义格式

修饰符 构造方法名(参数列表){ // 方法体 }

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用

构造方法后，代码如下：

public class Student { 
    private String name; 
    private int age; 
    // 无参数构造方法 
    public Student() {} 
    // 有参数构造方法 
    public Student(String name,int age) { 
        this.name = name; 
        this.age = age; 
    } 
}

注意事项

如果你不提供构造方法，系统会给出无参数构造方法。
如果你提供了构造方法，系统将不再提供无参数构造方法。
构造方法是可以重载的，既可以定义参数，也可以不定义参数。

14.6 标准代码——JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get方法。

public class ClassName{ 
//成员变量 
//构造方法 
//无参构造方法【必须】 
//有参构造方法【建议】 
//成员方法 
//getXxx() 
//setXxx() 
}

编写符合 JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student { 
    //成员变量 
    private String name; 
    private int age; 
    //构造方法 
    public Student() {} 
    public Student(String name,int age) { 
        this.name = name; 
        this.age = age; 
    }
    //成员方法 
    publicvoid setName(String name) { 
        this.name = name; 
    }
    public String getName() { 
        return name; 
    }
    public void setAge(int age) { 
        this.age = age; 
    }
    publicint getAge() { 
        return age; 
    } 
}

测试类，代码如下：

public class TestStudent { 
    public static void main(String[] args) { 
        //无参构造使用 
        Student s= new Student(); 
        s.setName("柳岩"); 
        s.setAge(18); 
        System.out.println(s.getName()+"‐‐‐"+s.getAge());
        //带参构造使用 
        Student s2= new Student("赵丽颖",18); 
        System.out.println(s2.getName()+"‐‐‐"+s2.getAge()); 
    } 
}

第十五章 Scanner类

15.1 什么是Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。例如，以下代码使用户能够从 System.in 中读取一个数：

Scanner sc = new Scanner(System.in); int i = sc.nextInt();

备注：System.in 系统输入指的是通过键盘录入数据。

15.2 引用类型使用步骤

导包

使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。格式：

import 包名.类名;

举例：

java.util.Scanner;

创建对象

使用该类的构造方法，创建一个该类的对象。格式：

数据类型 变量名 = new 数据类型(参数列表);

举例：

Scanner sc = new Scanner(System.in);

调用方法

调用该类的成员方法，完成指定功能。格式：

变量名.方法名();

举例：

int i = sc.nextInt(); // 接收一个键盘录入的整数

15.3 Scanner使用步骤

查看类

java.util.Scanner：该类需要import导入后使用。

查看构造方法

public Scanner(InputStream source) : 构造一个新的 Scanner ，它生成的值是从指定的输入流扫描的。

查看成员方法

public int nextInt()：将输入信息的下一个标记扫描为一个int值。

使用Scanner类，完成接收键盘录入数据的操作，代码如下：

//1. 导包 
import java.util.Scanner; 
public class Demo01_Scanner { 
    public static void main(String[] args) { 
        //2. 创建键盘录入数据的对象 
        Scanner sc = new Scanner(System.in); 
        //3. 接收数据 
        System.out.println("请录入一个整数："); 
        int i = sc.nextInt(); 
        //4. 输出数据 
        System.out.println("i:"+i); 
    } 
}

15.4 练习

求和

键盘录入两个数据并求和，代码如下：

import java.util.Scanner; 
public class Test01Scanner { 
    public static void main(String[] args) { 
        // 创建对象 
        Scanner sc = new Scanner(System.in); 
        // 接收数据 
        System.out.println("请输入第一个数据："); 
        int a = sc.nextInt(); 
        System.out.println("请输入第二个数据："); 
        int b = sc.nextInt(); 
        // 对数据进行求和 
        int sum = a + b;
        System.out.println("sum:" + sum); 
    } 
}

取最值

键盘录入三个数据并获取最大值，代码如下：

import java.util.Scanner; 
public class Test02Scanner { 
    public static void main(String[] args) { 
        // 创建对象 
        Scanner sc = new Scanner(System.in); 
        // 接收数据 
        System.out.println("请输入第一个数据："); 
        int a = sc.nextInt(); 
        System.out.println("请输入第二个数据："); 
        int b = sc.nextInt(); 
        System.out.println("请输入第三个数据："); 
        int c = sc.nextInt(); 
        // 如何获取三个数据的最大值 
        int temp = (a > b ? a : b); 
        int max = (temp > c ? temp : c); 
        System.out.println("max:" + max); 
    } 
}

15.5 匿名对象

概念

创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应用

场景非常有限。

匿名对象 ：没有变量名的对象。

格式：

new 类名(参数列表)；

举例：

new Scanner(System.in)；

应用场景

创建匿名对象直接调用方法，没有变量名。

new Scanner(System.in).nextInt();

一旦调用两次方法，就是创建了两个对象，造成浪费，请看如下代码。

new Scanner(System.in).nextInt(); new Scanner(System.in).nextInt();

小贴士：一个匿名对象，只能使用一次。

匿名对象可以作为方法的参数和返回值

作为参数：

class Test { 
    public static void main(String[] args) { 
        // 普通方式 
        Scanner sc = new Scanner(System.in); 
        input(sc); 
        //匿名对象作为方法接收的参数 
        input(new Scanner(System.in)); 
    }
    public static void input(Scanner sc){ 
        System.out.println(sc); 
    } 
}

作为返回值

第十六章 Random类

16.1 什么是Random类

此类的实例用于生成伪随机数。

例如，以下代码使用户能够得到一个随机数：

Random r = new Random(); int i = r.nextInt();

16.2 Rando使用步骤

查看类

java.util.Random：该类需要 import导入使后使用。

查看构造方法

public Random()：创建一个新的随机数生成器。

查看成员方法

public int nextInt(int n) ：返回一个伪随机数，范围在0（包括）和指定值 n （不包括）之间的int 值。

使用Random类，完成生成3个10以内的随机整数的操作，代码如下：

//1. 导包 
import java.util.Random; 
public class Demo01_Random { 
    public static void main(String[] args) { 
        //2. 创建键盘录入数据的对象 
        Random r = new Random(); 
        for(int i = 0; i < 3; i++){ 
            //3. 随机生成一个数据 
            int number = r.nextInt(10); 
            //4. 输出数据 
            System.out.println("number:"+ number); 
        } 
    } 
}

备注：创建一个 Random 对象，每次调用 nextInt() 方法，都会生成一个随机数。

16.3 练习

获取随机数

获取1-n之间的随机数，包含n，代码如下：

// 导包 
import java.util.Random; 
public class Test01Random { 
    public static void main(String[] args) { 
        int n = 50; 
        // 创建对象 
        Random r = new Random(); 
        // 获取随机数 
        int number = r.nextInt(n) + 1; 
        // 输出随机数 
        System.out.println("number:" + number); 
    } 
}

猜数字小游戏

游戏开始时，会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ，会与number作比

较，系统提示大了或者小了，直到玩家猜中，游戏结束。

小贴士：先运行程序代码，理解此题需求，经过分析后，再编写代码

// 导包 
import java.util.Random; 
public class Test02Random { 
    public static void main(String[] args) { 
        // 系统产生一个随机数1‐100之间的。 
        Random r = new Random(); 
        int number = r.nextInt(100) + 1; 
        while(true){ 
            // 键盘录入我们要猜的数据 
            Scanner sc = new Scanner(System.in); 
            System.out.println("请输入你要猜的数字(1‐100)："); 
            int guessNumber = sc.nextInt(); 
            // 比较这两个数据(用if语句) 
            if (guessNumber > number) { 
                System.out.println("你猜的数据" + guessNumber + "大了"); 
            } else if (guessNumber < number) { 
                System.out.println("你猜的数据" + guessNumber + "小了"); 
            } else { 
                System.out.println("恭喜你,猜中了"); 
                break; 
            } 
        } 
    } 
}

第十七章 ArrayList类

17.1 引入——对象数组

使用学生数组，存储三个学生对象，代码如下： 
    public 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; 
        }
        publicvoid setName(String name) { 
            this.name = name; 
        }
        publicint getAge() { 
            return age; 
        }
        publicvoid setAge(int age) { 
            this.age = age; 
        } 
    }
public class Test01StudentArray { 
    public static void main(String[] args) { 
        //创建学生数组 
        Student[] students = new Student[3]; 
        //创建学生对象 
        Student s1 = new Student("曹操",40); 
        Student s2 = new Student("刘备",35); 
        Student s3 = new Student("孙权",30); 
        //把学生对象作为元素赋值给学生数组 
        students[0] = s1; 
        students[1] = s2; 
        students[2] = s3; 
        //遍历学生数组 
        for(int x=0; x<students.length; x++) { 
            Student s = students[x]; 
            System.out.println(s.getName()+"‐‐‐"+s.getAge()); 
        } 
    } 
}

到目前为止，我们想存储对象数据，选择的容器，只有对象数组。而数组的长度是固定的，无法适应数据变化的需求。为了解决这个问题，Java提供了另一个容器java.util.ArrayList集合类,让我们可以更便捷的存储和操作对象数据。

17.2 什么是ArrayList类

java.util.ArrayList是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。ArrayList 中可不断添加元素，其大小也自动增长。

17.3 ArrayList使用步骤

查看类

java.util.ArrayList <E> ：该类需要 import导入使后使用。

<E> ，表示一种指定的数据类型，叫做泛型。 E，取自Element（元素）的首字母。在出现E的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。代码如下：

ArrayList<String>，ArrayList<Student>

查看构造方法

public ArrayList() ：构造一个内容为空的集合。

基本格式:

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

在JDK 7后,右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：

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

查看成员方法

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

参数 E e，在构造ArrayList对象时， <E>指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据

类型的对象。

使用ArrayList类，存储三个字符串元素，代码如下：

public class Test02StudentArrayList { 
    public static void main(String[] args) { 
        //创建学生数组 
        ArrayList<String> list = new ArrayList<>(); 
        //创建学生对象 
        String s1 = "曹操"; 
        String s2 = "刘备"; 
        String s3 = "孙权"; 
        //打印学生ArrayList集合 
        System.out.println(list); 
        //把学生对象作为元素添加到集合 
        list.add(s1); 
        list.add(s2); 
        list.add(s3);
        //打印学生ArrayList集合
        System.out.println(list);
    }
}

17.4 常用方法和遍历

对于元素的操作,基本体现在——增、删、查。常用的方法有：

public boolean add(E e)：将指定的元素添加到此集合的尾部。
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index)：返回此集合中指定位置上的元素。返回获取的元素。
public int size()：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

这些都是最基本的方法，操作非常简单，代码如下:

17.5 如何存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似

<int>不能写，但是存储基本数据类型对应的

包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：

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

我们发现，只有 Integer 和 Character 需要特殊记忆，其他基本类型只是首字母大写即可。那么存储基本类型数据，代码如下：

public class Demo02ArrayListMethod { 
    public static void main(String[] args) { 
        ArrayList<Integer> list = new ArrayList<Integer>(); 
        list.add(1); 
        list.add(2); 
        list.add(3); 
        list.add(4); 
        System.out.println(list); 
    } 
}

17.6 ArrayList练习

数值添加到集合

生成6个1~33之间的随机整数,添加到集合,并遍历

public class Test01ArrayList { 
    public static void main(String[] args) { 
        // 创建Random 对象 
        Random random = new Random(); 
        // 创建ArrayList 对象 
        ArrayList<Integer> list = new ArrayList<>(); 
        // 添加随机数到集合 
        for (int i = 0; i < 6; i++) { 
            int r = random.nextInt(33) + 1;
            list.add(r); 
        }
        // 遍历集合输出 
        for (int i = 0; i < list.size(); i++) { 
            System.out.println(list.get(i)); 
        } 
    } 
}

对象添加到集合

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

public class Test02ArrayList { 
    public static void main(String[] args) { 
        //创建集合对象 
        ArrayList<Student> list = new ArrayList<Student>(); 
        //创建学生对象 
        Student s1 = new Student("赵丽颖",18); 
        Student s2 = new Student("唐嫣",20); 
        Student s3 = new Student("景甜",25); 
        Student s4 = new Student("柳岩",19); 
        //把学生对象作为元素添加到集合中 
        list.add(s1); 
        list.add(s2); 
        list.add(s3); 
        list.add(s4); 
        //遍历集合 
        for(int x = 0; x < list.size(); x++) { 
            Student s = list.get(x); 
            System.out.println(s.getName()+"‐‐‐"+s.getAge()); 
        } 
    } 
}

打印集合方法

定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}扩起集合，使用@分隔每个元素。格式参照 {元素@元素@元素}。

public class Test03ArrayList { 
    public static void main(String[] args) { 
        // 创建集合对象 
        ArrayList<String> list = new ArrayList<String>(); 
        // 添加字符串到集合中 
        list.add("张三丰"); 
        list.add("宋远桥");
        list.add("张无忌"); 
        list.add("殷梨亭"); 
        // 调用方法 
        printArrayList(list); 
    }
    public static void printArrayList(ArrayList<String> list) { 
        // 拼接左括号 
        System.out.print("{"); 
        // 遍历集合 
        for (int i = 0; i < list.size(); i++) { 
            // 获取元素 
            String s = list.get(i); 
            // 拼接@符号 
            if (i != list.size() ‐ 1) { 
                System.out.print(s + "@"); 
            } else { 
                // 拼接右括号 
                System.out.print(s + "}"); 
            } 
        } 
    } 
}

获取集合方法

定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)

public class Test04ArrayList { 
    public static void main(String[] args) { 
        // 创建Random 对象 
        Random random = new Random(); 
        // 创建ArrayList 对象 
        ArrayList<Integer> list = new ArrayList<>(); 
        // 添加随机数到集合 
        for (int i = 0; i < 20; i++) { 
            int r = random.nextInt(1000) + 1; 
            list.add(r); 
        }
        // 调用偶数集合的方法 
        ArrayList<Integer> arrayList = getArrayList(list); 
        System.out.println(arrayList); 
    }
    public static ArrayList<Integer> getArrayList(ArrayList<Integer> list) { 
        // 创建小集合,来保存偶数 
        ArrayList<Integer> smallList = new ArrayList<>(); 
        // 遍历list 
        for (int i = 0; i < list.size(); i++) { 
            // 获取元素
            Integer num = list.get(i); 
            // 判断为偶数,添加到小集合中 
            if (num % 2 == 0){ 
                smallList.add(num); 
            } 
        }
        // 返回小集合 
        return smallList; 
    } 
}

第十八章 String类

18.1 String类概述

概述

java.lang.String类代表字符串。Java程序中所有的字符串文字（例如"abc"）都可以被看作是实现此类的实例。

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

特点

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

String s1 = "abc"; 
s1 += "d"; 
System.out.println(s1); // "abcd" 
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

因为String对象是不可变的，所以它们可以被共享。

String s1 = "abc"; 
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

“abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。

例如： 
String str = "abc"; 
相当于： 
char data[] = {'a', 'b', 'c'}; 
String str = new String(data); 
// String底层是靠字符数组实现的。

18.2 使用步骤

查看类
- java.lang.String：此类不需要导入。
查看构造方法
- public String()：初始化新创建的 String对象，以使其表示空字符序列。
- public String(char[] value)
- 通过当前参数中的字符数组来构造新的String。
- public String(byte[] bytes) :通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
- 构造举例，代码如下：

// 无参构造
String str = new String（）； 
// 通过字符数组构造 
char chars[] = {'a', 'b', 'c'}; 
String str2 = new String(chars); 
// 通过字节数组构造 
byte bytes[] = { 97, 98, 99 }; 
String str3 = new String(bytes);

18.3 常用方法

判断功能的方法

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

public class String_Demo01 { 
    public static void main(String[] args) { 
        // 创建字符串对象 
        String s1 = "hello"; 
        String s2 = "hello"; 
        String s3 = "HELLO"; 
        // 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 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

获取功能的方法

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

转换功能的方法

public char[] toCharArray ()：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement)：将与target匹配的字符串使用replacement字符串替换。

方法演示，代码如下：

public class String_Demo03 { 
    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.println(chs[x]); 
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
        // byte[] getBytes ():把字符串转换为字节数组 
        byte[] bytes = s.getBytes(); 
        for(int x = 0; x < bytes.length; x++) { 
            System.out.println(bytes[x]); 
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
        // 替换字母it为大写IT
        String str = "itcast itheima"; 
        String replace = str.replace("it", "IT"); 
        System.out.println(replace); // ITcast ITheima 
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
    } 
}

CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

分割功能的方法

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

方法演示，代码如下:

public class String_Demo03 { 
    public static void main(String[] args) { 
        //创建字符串对象 
        String s = "aa|bb|cc"; 
        String[] strArray = s.split("|"); // ["aa","bb","cc"] 
        for(int x = 0; x < strArray.length; x++) { 
            System.out.println(strArray[x]); // aa bb cc 
        } 
    } 
}

18.4 String类的练习

拼接字符串

定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。

public class StringTest1 { 
    public static void main(String[] args) { 
        //定义一个int类型的数组 
        int[] arr = {1, 2, 3}; 
        //调用方法 
        String s = arrayToString(arr); 
        //输出结果 
        System.out.println("s:" + s); 
    }
    /* 
* 写方法实现把数组中的元素按照指定的格式拼接成一个字符串 
* 两个明确： 
* 返回值类型：String 
* 参数列表：int[] arr 
*/ 
    public static String arrayToString(int[] arr) { 
        // 创建字符串s
        String s = new String("["); 
        // 遍历数组，并拼接字符串 
        for (int x = 0; x < arr.length; x++) { 
            if (x == arr.length ‐ 1) { 
                s = s.concat(arr[x] + "]"); 
            } else { 
                s = s.concat(arr[x] + "#"); 
            } 
        }
        return s; 
    } 
}

统计字符个数

键盘录入一个字符，统计字符串中大小写字母及数字字符个数

public class StringTest2 { 
    public static void main(String[] args) { 
        //键盘录入一个字符串数据 
        Scanner sc = new Scanner(System.in); 
        System.out.println("请输入一个字符串数据："); 
        String s = sc.nextLine(); 
        //定义三个统计变量，初始化值都是0 
        int bigCount = 0; 
        int smallCount = 0; 
        int numberCount = 0; 
        //遍历字符串，得到每一个字符 
        for(int x=0; x<s.length(); x++) { 
            char ch = s.charAt(x); 
            //拿字符进行判断 
            if(ch>='A'&&ch<='Z') { 
                bigCount++; 
            }else if(ch>='a'&&ch<='z') { 
                smallCount++; 
            }else if(ch>='0'&&ch<='9') { 
                numberCount++; 
            }else { 
                System.out.println("该字符"+ch+"非法"); 
            } 
        }
        //输出结果 
        System.out.println("大写字符："+bigCount+"个"); 
        System.out.println("小写字符："+smallCount+"个"); 
        System.out.println("数字字符："+numberCount+"个"); 
    } 
}