面向对象
- 面向对象思想的概述
- 面向对象思想的举例
- 类和对象的关系
- 对象的创建及其使用
- 只有一个对象的内存图
- 两个对象使用同一个方法的内存图
- 两个引用指向同一个对象的内存图
- 使用对象类型作为方法的参数
- 使用对象类型作为方法的返回值
- 成员变量和局部变量的区别
- 面向对象三大特征之封装性
- private关键字的作用及使用
- 练习使用private关键字定义学生类
- this关键字的作用
- 构造方法
- 定义一个标准的类
- API概述和使用步骤
- Scanner类的使用
- Scanner练习
- 匿名对象的说明
- 匿名对象作为方法的参数和返回值
- Random概述和基本使用
- Random练习
- 对象数组
- ArrayList集合概述和基本使用
- ArrayList集合的常用方法和遍历
- ArrayList集合存储基本数据类型
- ArrayList练习
面向对象思想的概述
面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。
import java.util.Arrays;
public class Demo01PrintArray {
public static void main(String[] args) {
int[] array = { 10, 20, 30, 40, 50, 60 };
// 要求打印格式为：[10, 20, 30, 40, 50]
// 使用面向过程，每一个步骤细节都要亲力亲为。
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) { // 如果是最后一个元素
System.out.println(array[i] + "]");
} else { // 如果不是最后一个元素
System.out.print(array[i] + ", ");
}
}
System.out.println("==============");
// 使用面向对象
// 找一个JDK给我们提供好的Arrays类，
// 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
System.out.println(Arrays.toString(array));
}
}
面向对象思想的举例
洗衣服:
面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
面向对象：把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来
区别:
面向过程：强调步骤。
面向对象：强调对象，这里的对象就是洗衣机。
特点
面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。
类和对象的关系
类是对一类事物的描述，是抽象的
对象是对一类事物的实例，是具体的
类是对象的模板，对象是类的实体
什么是类：
类就可以看做 模板 或者 设计图纸
类中 有 属性（成员变量） 和 方法
属性：就是该事物的状态信息。
行为：就是该事物能够做什么。
举例：小猫。
属性：名字、体重、年龄、颜色。
行为：走、跑、叫。
定义一个类，用来模拟“学生”事物。其中就有两个组成部分：
属性（是什么）：
姓名
年龄
行为（能做什么）：
吃饭
睡觉
学习
对应到Java的类当中：
成员变量（属性）：
String name; // 姓名
int age; // 年龄
成员方法（行为）：
public void eat() {} // 吃饭
public void sleep() {} // 睡觉
public void study() {} // 学习
注意事项：
- 成员变量是直接定义在类当中的，在方法外边。
- 成员方法不要写static关键字。
public class Student {
// 成员变量
String name; // 姓名
int age; // 姓名
// 成员方法
public void eat() {
System.out.println("吃饭饭！");
}
public void sleep() {
System.out.println("睡觉觉！");
}
public void study() {
System.out.println("学习！");
}
}
什么是对象
是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。
现实中，一类事物的一个实例：一只小猫。
举例：一只小猫。
属性：tom、5kg、2years、yellow。
行为：溜墙根走、蹦跶的跑、喵喵叫
对象的创建及其使用
通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。
-
导包：也就是指出需要使用的类，在什么位置。
import 包名称.类名称;
import cn.itcast.day06.demo01.Student;
对于和当前类属于同一个包的情况，可以省略导包语句不写。 -
创建，格式：
类名称 对象名 = new 类名称();
Student stu = new Student(); -
使用，分为两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)
（也就是，想用谁，就用对象名点儿谁。）
注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。
public class Demo01Student {
public static void main(String[] args) {
// 1. 导包。
// 我需要使用的Student类，和我自己Demo01Student位于同一个包下，所以省略导包语句不写
// 2. 创建，格式：
// 类名称 对象名 = new 类名称();
// 根据Student类，创建了一个名为stu的对象
Student stu = new Student();
// 3. 使用其中的成员变量，格式：
// 对象名.成员变量名
System.out.println(stu.name); // null
System.out.println(stu.age); // 0
System.out.println("=============");
// 改变对象当中的成员变量数值内容
// 将右侧的字符串，赋值交给stu对象当中的name成员变量
stu.name = "赵丽颖";
stu.age = 18;
System.out.println(stu.name); // 赵丽颖
System.out.println(stu.age); // 18
System.out.println("=============");
// 4. 使用对象的成员方法，格式：
// 对象名.成员方法名()
stu.eat();
stu.sleep();
stu.study();
}
}
只有一个对象的内存图
两个对象使用同一个方法的内存图
两个引用指向同一个对象的内存图
使用对象类型作为方法的参数
使用对象类型作为方法的返回值
成员变量和局部变量的区别
局部变量和成员变量
-
定义的位置不一样【重点】
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中 -
作用范围不一样【重点】
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类全都可以通用。 -
默认值不一样【重点】
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样 -
内存的位置不一样（了解）
局部变量：位于栈内存
成员变量：位于堆内存 -
生命周期不一样（了解）
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
public class Demo01VariableDifference {
String name; // 成员变量
public void methodA() {
int num = 20; // 局部变量
System.out.println(num);
System.out.println(name);
}
public void methodB(int param) { // 方法的参数就是局部变量
// 参数在方法调用的时候，必然会被赋值的。
System.out.println(param);
int age; // 局部变量
// System.out.println(age); // 没赋值不能用
// System.out.println(num); // 错误写法！
System.out.println(name);
}
}
面向对象三大特征之封装性
面向对象三大特征：封装、继承、多态。
封装性在Java当中的体现：
- 方法就是一种封装
- 关键字private也是一种封装
封装就是将一些细节信息隐藏起来，对于外界不可见。
public class Demo02Method {
public static void main(String[] args) {
int[] array = {5, 15, 25, 20, 100};
int max = getMax(array);
System.out.println("最大值：" + max);
}
// 给我一个数组，我还给你一个最大值
public static int getMax(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
}
private关键字的作用及使用
public class Demo03Person {
public static void main(String[] args) {
Person person = new Person();
person.show();
person.name = "赵丽颖";
// person.age = -20; // 直接访问private内容，错误写法！
person.setAge(20);
person.show();
}
}
问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。
解决方案：用private关键字将需要保护的成员变量进行修饰。
一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
但是！超出了本类范围之外就不能再直接访问了。
间接访问private成员变量，就是定义一对儿Getter/Setter方法
必须叫setXxx或者是getXxx命名规则。
对于Getter来说，不能有参数，返回值类型和成员变量对应；
对于Setter来说，不能有返回值，参数类型和成员变量对应。
public class Person {
String name; // 姓名
private int age; // 年龄
public void show() {
System.out.println("我叫：" + name + "，年龄：" + age);
}
// 这个成员方法，专门用于向age设置数据
public void setAge(int num) {
if (num < 100 && num >= 9) { // 如果是合理情况
age = num;
} else {
System.out.println("数据不合理！");
}
}
// 这个成员方法，专门私语获取age的数据
public int getAge() {
return age;
}
}
练习使用private关键字定义学生类
/*
对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
*/
public class Student {
private String name; // 姓名
private int age; // 年龄
private boolean male; // 是不是爷们儿
public void setName(String str){
name=str;
}
public String getName(){
return name;
}
public void setAge(int num){
age=num;
}
public int getAge(){
return age;
}
public void setMale(boolean b){
male=b;
}
public boolean isMale(){
return male;
}
}
public class Demo04Student {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("鹿晗");
stu.setAge(20);
stu.setMale(true);
System.out.println("姓名：" + stu.getName());
System.out.println("年龄：" + stu.getAge());
System.out.println("是不是爷们儿：" + stu.isMale());
}
}
this关键字的作用
当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名
“通过谁调用的方法，谁就是this。”
public class Person {
String name; // 我自己的名字
// 参数name是对方的名字
// 成员变量name是自己的名字
public void sayHello(String name) {
System.out.println(name + "，你好。我是" + this.name);
System.out.println(this);
}
}
public class Demo01Person {
public static void main(String[] args) {
Person person = new Person();
// 设置我自己的名字
person.name = "王健林";
person.sayHello("王思聪");
System.out.println(person); // 地址值
}
}
构造方法
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称(参数类型 参数名称) {
方法体
}
注意事项：
- 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
- 构造方法不要写返回值类型，连void都不写
- 构造方法不能return一个具体的返回值
- 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
public Student() {} - 一旦编写了至少一个构造方法，那么编译器将不再赠送。
- 构造方法也是可以进行重载的。
重载：方法名称相同，参数列表不同。
public class Student {
// 成员变量
private String name;
private int age;
// 无参数的构造方法
public Student() {
System.out.println("无参构造方法执行啦！");
}
// 全参数的构造方法
public Student(String name, int age) {
System.out.println("全参构造方法执行啦！");
this.name = name;
this.age = age;
}
// Getter Setter
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 class Demo02Student {
public static void main(String[] args) {
Student stu1 = new Student(); // 无参构造
System.out.println("============");
Student stu2 = new Student("赵丽颖", 20); // 全参构造
System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
// 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
stu2.setAge(21); // 改变年龄
System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
}
}
定义一个标准的类
一个标准的类通常要拥有下面四个组成部分：
- 所有的成员变量都要使用private关键字修饰
- 为每一个成员变量编写一对儿Getter/Setter方法
- 编写一个无参数的构造方法
- 编写一个全参数的构造方法
这样标准的类也叫做Java Bean
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;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
这里我们只用写
private String name; // 姓名
private int age; // 年龄
其余的都是点击Code自动生成的
public class Demo01Student {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("迪丽热巴");
stu1.setAge(20);
System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
System.out.println("=================");
Student stu2 = new Student("古力娜扎", 21);
System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
stu2.setAge(22);
System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
}
}
set就是赋值、 改变 get 就是获取
API概述和使用步骤
API类似于字典
使用步骤：
- 打开帮助文档。 2. 点击显示，找到索引，看到输入框。 3. 你要找谁？在输入框里输入，然后回车。 4. 看包。java.lang下的类不需要导包，其他需要。 5. 看类的解释和说明。 6. 学习构造方法 7. 使用成员方法。
Scanner类的使用
Scanner类的功能：可以实现键盘输入数据，到程序当中。
引用类型的一般使用步骤：
-
导包
import 包路径.类名称;
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。 -
创建
类名称 对象名 = new 类名称(); -
使用
对象名.成员方法名()
获取键盘输入的一个int数字：int num = sc.nextInt();
获取键盘输入的一个字符串：String str = sc.next();
import java.util.Scanner; // 1. 导包
public class Demo01Scanner {
public static void main(String[] args) {
// 2. 创建
// 备注：System.in代表从键盘进行输入
Scanner sc = new Scanner(System.in);
// 3. 获取键盘输入的int数字
int num = sc.nextInt();
System.out.println("输入的int数字是：" + num);
// 4. 获取键盘输入的字符串
String str = sc.next();
System.out.println("输入的字符串是：" + str);
}
}
成员方法 nextInt(); next(); 都是通过查找 API Scanner类的方法。
Scanner练习
键盘输入两个数字求和
题目：
键盘输入两个int数字，并且求出和值。
思路：
- 既然需要键盘输入，那么就用Scanner
- Scanner的三个步骤：导包、创建、使用
- 需要的是两个数字，所以要调用两次nextInt方法
- 得到了两个数字，就需要加在一起。
- 将结果打印输出。
import java.util.Scanner;//导包
public class Demo02ScannerSum {
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);
}
}
键盘输入三个数求最大值
题目：
键盘输入三个int数字，然后求出其中的最大值。
思路：
- 既然是键盘输入，肯定需要用到Scanner
- Scanner三个步骤：导包、创建、使用nextInt()方法
- 既然是三个数字，那么调用三次nextInt()方法，得到三个int变量
- 无法同时判断三个数字谁最大，应该转换成为两个步骤：
4.1 首先判断前两个当中谁最大，拿到前两个的最大值
4.2 拿着前两个中的最大值，再和第三个数字比较，得到三个数字当中的最大值 - 打印最终结果
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();
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);
}
}
匿名对象的说明
创建对象的标准格式：
类名称 对象名 = new 类名称();
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称();
注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。
public class Demo01Anonymous {
public static void main(String[] args) {
// 左边的one就是对象的名字
Person one = new Person();
one.name = "高圆圆";
one.showName(); // 我叫高圆圆
System.out.println("===============");
// 匿名对象
new Person().name = "赵又廷";
new Person().showName(); // 我叫：null
}
}
匿名对象作为方法的参数和返回值
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));
Scanner sc = methodReturn();
int num = sc.nextInt();
System.out.println("输入的是：" + num);
}
public static void methodParam(Scanner sc) {
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类用来生成随机数字。使用起来也是三个步骤：
-
导包
import java.util.Random; -
创建
Random r = new Random(); // 小括号当中留空即可 -
使用
获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt()
获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)
实际上代表的含义是：[0,3)，也就是0~2
import java.util.Random;
public class Demo01Random {
public static void main(String[] args) {
Random r = new Random();
int num = r.nextInt();
System.out.println("随机数是：" + num);
}
}
import java.util.Random;
public class Demo02Random {
public static void main(String[] args) {
Random r = new Random();
for (int i = 0; i < 100; i++) {
int num = r.nextInt(10); // 范围实际上是0~9
System.out.println(num);
}
}
}
Random练习
生成1-n的随机数
题目要求：
根据int变量n的值，来获取随机数字，范围是[1,n]，可以取到1也可以取到n。
思路：
- 定义一个int变量n，随意赋值
- 要使用Random：三个步骤，导包、创建、使用
- 如果写10，那么就是0-9，然而想要的是1~10，可以发现：整体+1即可。
- 打印随机数字
import java.util.Random;
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);
}
}
}
猜数字小游戏
题目：
用代码模拟猜数字的小游戏。
思路：
- 首先需要产生一个随机数字，并且一旦产生不再变化。用Random的nextInt方法
- 需要键盘输入，所以用到了Scanner
- 获取键盘输入的数字，用Scanner当中的nextInt方法
- 已经得到了两个数字，判断（if）一下：
如果太大了，提示太大，并且重试；
如果太小了，提示太小，并且重试；
如果猜中了，游戏结束。 - 重试就是再来一次，循环次数不确定，用while(true)。 死循环 但是我可以用break 停止
import java.util.Random;
import java.util.Scanner;
public class Demo04RandomGame {
public static void main(String[] args) {
Random r = new Random();
int randomNum = r.nextInt(100) + 1; // [1,100]
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("游戏结束。");
}
}
下面是用for循环来做 限定了一个次数 到达了规定次数过后 没有猜出来就错了
public class Demo04RandomGame {
public static void main(String[] args) {
Random r = new Random();
int randomNum = r.nextInt(100) + 1; // [1,100]
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 5; i++) {
System.out.println("请输入你猜测的数字：");
int guessNum = sc.nextInt(); // 键盘输入猜测的数字
if (i==4){
System.out.println("用了5次机会还是没有猜出来，你输了，游戏结束。");
}else{
if(guessNum>randomNum){
System.out.println("数字过大，请重试");
}else if (guessNum<randomNum){
System.out.println("数字过小，请重试");
}else {
System.out.println("恭喜你，猜对了。");
System.out.println("游戏结束");
break;
}
}
}
}
}
这里用for 循环 我要判定它第5次机会用玩了但是还是没有猜出来 所以我用 if（i==4）{}这里判断第5次了，还是没有猜出来，就输了。然后再用一个else{}代表第一次到第4次的时候 再else{ }的括号里面再嵌套一个if…else…if 的语句判断数字过大、过小和猜对的情况
对象数组
Person类
这么多东西其实我们就写了
private String name;
private int age;
其余的都是自动生成的。 编写一个无参数的构造方法。编写一个全参数的构造方法。
然后就是Getter和Setter
public class Person {
private String name;
private int age;
public Person(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;
}
public Person() {
}
}
题目：
定义一个数组，用来存储3个Person对象。
数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变。
public class Demo01Array {
public static void main(String[] args) {
// 首先创建一个长度为3的数组，里面用来存放Person类型的对象
Person[] array = new Person[3];
Person one = new Person("迪丽热巴", 18);
Person two = new Person("古力娜扎", 28);
Person three = new Person("玛尔扎哈", 38);
// 将one当中的地址值赋值到数组的0号元素位置
array[0] = one;
array[1] = two;
array[2] = three;
System.out.println(array[0]); // 地址值
System.out.println(array[1]); // 地址值
System.out.println(array[2]); // 地址值
System.out.println(array[1].getName()); // 古力娜扎
}
}
ArrayList集合概述和基本使用
数组的长度不可以发生改变。
但是ArrayList集合的长度是可以随意变化的。
对于ArrayList来说，有一个尖括号代表泛型。
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。
注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号：[ ]
import java.util.ArrayList;//导包
public class Demo02ArrayList {
public static void main(String[] args) {
// 创建了一个ArrayList集合，集合的名称是list，里面装的全都是String字符串类型的数据
// 备注：从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
ArrayList<String> list = new ArrayList<>();
System.out.println(list); // []
// 向集合当中添加一些数据，需要用到add方法。
list.add("赵丽颖");
System.out.println(list); // [赵丽颖]
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("玛尔扎哈");
System.out.println(list); // [赵丽颖, 迪丽热巴, 古力娜扎, 玛尔扎哈]
// list.add(100); // 错误写法！因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行
}
}
ArrayList集合的常用方法和遍历
ArrayList当中的常用方法有：
public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但是对于其他集合（今后学习）来说，add添加动作不一定成功。
public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。
import java.util.ArrayList;
public class Demo03ArrayListMethod {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
System.out.println(list); // []
// 向集合中添加元素：add
boolean success = list.add("柳岩");
System.out.println(list); // [柳岩]
System.out.println("添加的动作是否成功：" + success); // true
list.add("高圆圆");
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(3);
System.out.println("被删除的人是：" + whoRemoved); // 李小璐
System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 贾乃亮]
// 获取集合的长度尺寸，也就是其中元素的个数
int size = list.size();
System.out.println("集合的长度是：" + size);
}
}
遍历打印输出：
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++) {//用size获取ArrayList集合的长度
System.out.println(list.get(i));//get获取ArrayList中的元素值。
}
}
}
ArrayList集合存储基本数据类型
如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。
基本类型 包装类（引用类型，包装类都位于java.lang包下）
byte Byte
short Short
int Integer 【特殊】
long Long
float Float
double Double
char Character 【特殊】
boolean Boolean
从JDK 1.5+开始，支持自动装箱、自动拆箱。
自动装箱：基本类型 --> 包装类型
自动拆箱：包装类型 --> 基本类型
import java.util.ArrayList;
public class Demo05ArrayListBasic {
public static void main(String[] args) {
ArrayList<String> listA = new ArrayList<>();
// 错误写法！泛型只能是引用类型，不能是基本类型
// ArrayList<int> listB = new ArrayList<>();
ArrayList<Integer> listC = new ArrayList<>();
listC.add(100);
listC.add(200);
System.out.println(listC); // [100, 200]
int num = listC.get(1);
System.out.println("第1号元素是：" + num);
}
}
ArrayList练习
存储随机数字
题目：
生成6个1~33之间的随机整数，添加到集合，并遍历集合。
思路：
- 需要存储6个数字，创建一个集合，
- 产生随机数，需要用到Random
- 用循环6次，来产生6个随机数字：for循环
- 循环内调用r.nextInt(int n)，参数是33，032，整体+1才是133
- 把数字添加到集合中：add
- 遍历集合：for、size、get
import java.util.ArrayList;
import java.util.Random;
public class Demo01ArrayListRandom {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Random r= new Random();
for (int i = 0; i < 6; i++) {
int num =r.nextInt(33)+1;
boolean success = list.add(num);
System.out.println("添加是否成功"+success);
}
//遍历集合
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
存储自定义对象
自定义一个标准的类：定义一个全参和无参的构造方法，然后再Getter和Setter。
Student的类
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;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
题目：
自定义4个学生对象，添加到集合，并遍历。
思路：
- 自定义Student学生类，四个部分。
- 创建一个集合，用来存储学生对象。泛型：Student
- 根据类，创建4个学生对象。
- 将4个学生对象添加到集合中：add
- 遍历集合：for、size、get
public class Demo02ArrayListStudent {
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());
}
}
}
按指定格式遍历集合字符串
题目：
定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}扩起集合，使用@分隔每个元素。
格式参照 {元素@元素@元素}。
System.out.println(list); [10, 20, 30]
printArrayList(list); {10@20@30}
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);
}
/*
定义方法的三要素
返回值类型：只是进行打印而已，没有运算，没有结果；所以用void
方法名称：printArrayList
参数列表：ArrayList
*/
public static void printArrayList(ArrayList<String> list) {//（）括号里面写ArrayList参数 ArrayList<String> list
// {10@20@30} 要这种效果
System.out.print("{");
for (int i = 0; i < list.size(); i++) {
String name = list.get(i);//将值赋给 String类型的name
if (i == list.size() - 1) {
System.out.println(name + "}");//如果是最后一个就是名字+}
} else {
System.out.print(name + "@");// 不是最后一个就是名字+@
}
}
}
}
筛选集合当中的随机数
题目：
用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。
要求使用自定义的方法来实现筛选。
分析：
- 需要创建一个大集合，用来存储int数字：
- 随机数字就用Random nextInt
- 循环20次，把随机数字放入大集合：for循环、add方法
- 定义一个方法，用来进行筛选。
筛选：根据大集合，筛选符合要求的元素，得到小集合。
三要素
返回值类型：ArrayList小集合（里面元素个数不确定）
方法名称：getSmallList
参数列表：ArrayList大集合（装着20个随机数字） - 判断（if）是偶数：num % 2 == 0
- 如果是偶数，就放到小集合当中，否则不放。
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> smallList = getSmallList(bigList);
System.out.println("偶数总共有多少个：" + smallList.size());
for (int i = 0; i < smallList.size(); i++) {
System.out.println(smallList.get(i));
}
}
// 这个方法，接收大集合参数，返回小集合结果
public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {//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;
}
}
312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
