对象数组
package cn.luis.demo4;
/*
题目：定义一个数组，用来存储三个person对象（对象数组）
数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变
*/
public class Demo01Array {
public static void main(String[] args) {
//首先创建一个长度为3的数组，用来存放person类型的对象。
Person[] array = new Person[3]; // 自定义的Person类型数组（用来存放person对象）
System.out.println(array[0]); //初始值是null
//创建三个对象 直接通过构造方法来进行成员变量的赋值
Person one = new Person("迪丽热巴",18); //one是地址值
Person two = new Person("古力娜扎",28);
Person three = new Person("马尔扎哈",38);
//把one，two，three三个对象放到数组
array[0] = one; //将one当中的地址值，赋值到数组的0号元素位置
array[1] = two;
array[2] = three;
//任何数据类型都可以作为数组当中元素的类型(包括：基本类型，字符串，自定义的person类型等等)
System.out.println(array[0]); //地址值
System.out.println(array[1]);
System.out.println(array[2]);
/*
Person person = array[1]; //把1号地址值的内容传给person
// array[1]是个地址值，它是two的地址，two就是古力娜扎（getName()）
System.out.println(person.getName()); //古力娜扎
*/
System.out.println(array[1].getName()); //和上面两行作用相同
}
}
结果：
null
cn.luis.demo4.Person@2ac1fdc4
cn.luis.demo4.Person@5f150435
cn.luis.demo4.Person@1c53fd30
古力娜扎
到目前为止，我们想存储对象数据，选择的容器，只有对象数组。而数组的长度是固定的，无法适应数据变化的需求。
为了解决这个问题，Java提供了另一个容器 java.util.ArrayList集合类，让我们可以更便捷的存储和操作对象数据。
概述
java.util.ArrayList是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。ArrayList中可不断添加元素，其大小也自动增长。
查看类
java.util.ArrayList <E>：该类需要import导入使后使用。
<E>:表示一种指定的数据类型，叫做泛型。E，取自Element（元素）的首字母。在出现E的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。代码如下：
Arraylist<String>，Arraylist<Student>
查看构造方法
public ArrayList()：构造一个内容为空的集合。
基本格式：
Arraylist<String> list = new ArrayList<String>();
在JDK7后，右侧泛型的尖括号之内可以留空，但是心仍然要写。简化格式：
Arraylist<String> list = new Arraylist<>();
查看成员方法
public boolean add（E e）：将指定的元素添加到此集合的尾部。
参数E e，在构造ArrayList对象时，<E>指定了什么数据类型，那么add(E e)方法中，只能添加什么数据类型的对象。
注意
-
对于
ArrayList来说，有一个尖括号<>代表泛型。- 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
- 泛型只能是引用类型，不能是基本类型
- 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
-
对于
ArrayList集合来说，直接打印得到的不是地址值，而是内容。- 如果内容是空，得到的是空的中括号
[]
- 如果内容是空，得到的是空的中括号
ArrayList<String> list = new ArrayList<>();
从JDK1.7+开始，右侧的尖括号内容可以不写内容（1.6要在右面尖括号也写上String）
示例
使用ArrayList类，存储三个字符串元素，代码如下：
package cn.luis.demo4;
import java.util.ArrayList;
/*
数组的长度不可以发生改变。
但是ArrayList集合的长度是可以随意变化的
*/
public class Demo02ArrayList {
public static void main(String[] args) {
//创建了一个ArrayList集合，集合的名称是list，里面装的都是String字符串类型的数据
ArrayList<String> list = new ArrayList<>(); //new的是一个集合对象
System.out.println(list); // []
//向集合当中添加一些数据，需要用到add()方法
list.add("赵丽颖");
System.out.println(list);
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
System.out.println(list);
//list.add(100); //错误写法！因为尖括号中要求是字符串类型
}
}
结果：
[]
[赵丽颖]
[赵丽颖, 迪丽热巴, 古力娜扎, 马尔扎哈]
常用方法和遍历
常用方法
对于元素的操作，基本体现在——增、删、查。常用的方法有：
-
public boolean add(E e)：将指定的元素添加到此集合的尾部。向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用 -
public E remove(int index)：移除此集合中指定位置上的元素。返回被删除的元素。返回值是被删除的元素
-
public E get(int index)：返回此集合中指定位置上的元素。返回获取的元素。 -
public int size()：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
这些都是最基本的方法，操作非常简单，代码如下：
package cn.luis.demo4;
import java.util.ArrayList;
public class Demo03ArrayListMethod {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
System.out.println(list); // []
// 1. 向集合中添加元素：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);
// 2. 从集合中获取元素：get(),索引值从0开始
String name = list.get(2); // 赵又廷（泛型创建的时候是String 所以用String类型接收）
System.out.println("第2号索引位置是：" + name); // 返回值就是对应位置的元素
// 3. 从集合中删除元素：remove(),索引值从0开始
String whoRemoved = list.remove(3); // 返回值是被删除的元素
System.out.println(list);
System.out.println("最后谁没了：" + whoRemoved);
// 4. 获取集合的长度，也就是 其中的元素个数
int size = list.size(); // 返回值是集合中包含的元素个数
System.out.println("集合的长度是：" + size);
}
}
结果：
[]
[柳岩]
添加的动作是否成功：true
[柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮]
第2号索引位置是：赵又廷
[柳岩, 高圆圆, 赵又廷, 贾乃亮]
最后谁没了：李小璐
集合的长度是：4
集合的遍历
package cn.luis.demo4;
import java.util.ArrayList;
public class Demo04ArrayListEach {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
// 遍历集合 （快捷方法： list.fori + 回车）
for (int i = 0; i < list.size(); i++) { // i < array.length 和遍历数组类似
// System.out.println(list); // [迪丽热巴, 古力娜扎, 马尔扎哈]
System.out.println(list.get(i)); // array[i]
}
}
}
结果：
迪丽热巴
古力娜扎
马尔扎哈
存储基本数据类型
ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似<int>不能写.
但是存储基本数据类型对应的包装类型是可以的。
所以，想要存储基本类型数据，<>中的数据类型，必须转换后才能编写，转换写法如下：
| 基本类型 | 基本类型包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
引用类型，包装类都位于java.lang包下 故不用导包
如果想向集合ArrayList当中储存基本类型数据，必须使用基本类型对应的“包装类”。
从JDK1.5开始，支持自动装箱、自动拆箱。
- 自动装箱： 基本类型自动变成包装类型
- 自动拆箱： 包装类型 --> 基本类型
代码：
package cn.luis.demo4;
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);
listC.add(300);
// 拿出数据
int num = listC.get(2);
System.out.println("第2号元素是：" + num); // 第2号元素是：300
}
}
集合作为方法的参数和返回值
作为方法的参数
定义以指定格式打印集合的方法（ArrayList类型作为参数），使用0扩起集合，使用@分隔每个元素。
格式参照:（元素@元素@元素}。
代码：
package cn.luis.demo5;
import java.util.ArrayList;
/*
题目：定义以指定格式打印集合的方法(ArralList类型作为参数)，使用{}扩起集合，使用@分隔每个元素。
格式参照 (元素@元素@元素)
System.out.println(list); [10,20,30]
printArrayList(list); {10@20@30}
*/
public class Demo03ArrayListParam {
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); // {张三丰@张作霖@张学良@杨虎城}
}
/*
定义方法三要素：
1.返回值：只是打印而已，没有运算，没有结果，所以用void
2.方法名称：printArrayList
3.参数列表：ArrayList
*/
// 传递进来的参数list 就是一个地址值 根据地址值.size就可以拿长度 地址值.get就可以拿元素
public static void printArrayList (ArrayList<String> list) {
// {10@20@30}
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 + "@");
}
}
}
}
结果：
[张三丰, 张作霖, 张学良, 杨虎城]
{张三丰@张作霖@张学良@杨虎城}
作为方法的返回值
获取集合方法
定义获取所有偶数元素集合的方法（ArrayList类型作为返回值）
package cn.luis.demo5;
import java.util.ArrayList;
import java.util.Random;
/*
用一个大集合存入10个随机数字，然后筛选其中的偶数元素，放到小集合当中。
要求使用自定义的方法来实现筛选。
分析：
1. 需要创建一个集合，用来存储int数字,<Integer>
2. 随机数字： Random nextInt
3. 循环20次，把随机数放入大集合:for循环、add方法
4. 自定义一个方法，用来进行筛选。
筛选：根据大集合，筛选符合要求的元素，得到小集合。
三要素：
返回值类型：ArrayList小集合（里面元素个数不确定）
方法名称：getSmallList
参数列表：ArrayList大集合（装着20个随机数字）
5. 判断是偶数： num % 2 == 0;
6. 如果是偶数，就放到小集合当中，否则不放。
*/
public class Demo04ArrayListReturn {
public static void main(String[] args) {
final int size = 10; // 10个随机数字
ArrayList<Integer> bigList = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < size; i++) {
int num = r.nextInt(100) + 1; // 【1，100】
bigList.add(num);
}
System.out.println("bigList:" + bigList);
// 将bigList存入的20个随机数字传入方法，并接收返回的smallList(里面都是偶数)
ArrayList<Integer> result = getSmallList(bigList);
// 遍历、计算偶数
for (int i = 0; i < result.size(); i++) {
System.out.print(result.get(i) + "\t");
}
System.out.println("\n偶数个数:" + 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);
}
}
System.out.println("smallList:" + smallList);
return smallList;
}
}
结果：
bigList:[86, 80, 11, 5, 57, 54, 2, 9, 97, 88]
smallList:[86, 80, 54, 2, 88]
86 80 54 2 88
偶数个数:5
案例：将随机数添加到集合
生成6个1-33之间的随机整数，添加到集合，并遍历
package cn.luis.demo5;
import java.util.ArrayList;
import java.util.Random;
/*
题目：生成6个1~33之间的随机整数，添加到集合，并遍历集合。
思路：
1.需要存储6个数字，创建一个集合，<Integer>
2.产生随机数，需要用到Random
3.用来循环6次，来产生6个随机数，for循环
4.循环内调用r.nextInt(int n),参数是33，【0,32】 需要整体 + 1
5.把数字添加到集合中：add
6.遍历集合：for、size、size
*/
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++) { // 往里添加6次
int num = r.nextInt(33) + 1; // 拿到随机数字：[0,32] ---> [1,33]
list.add(num);
}
// 遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + "\t");
}
// 结果：15 23 18 11 24 33
}
}
案例：将自定义对象添加到集合
自定义4个学生对象，添加到集合，并遍历
package cn.luis.demo5;
import java.util.ArrayList;
/*
练习：在集合中存储自定义的类型对象！！！
题目：自定义四个学生对象，添加到集合，并遍历。
思路：
1.自定义一个Student学生类，四个部分（。。。）。
2.创建一个集合，用来存储学生对象，泛型<Student>
3.根据类，创建四个学生对象。
4.将四个学生对象添加到集合中：add()
5.遍历集合： for、size、get size.fori
*/
public class Demo02ArrayListStudent {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>(); // not String类型
Student s1 = new Student("小明",15);
Student s2 = new Student("小李",16);
Student s3 = new Student("小王",25);
Student s4 = new Student("小强",25);
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s2);
//System.out.println(list); // 是地址值
for (int i = 0; i < list.size(); i++) {
//System.out.println(list.get(i)); // 错误！！ list.get(i) 是地址值
Student stu = list.get(i); // list.get(i)是Student类型
System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
}
}
}
结果：
姓名：小明，年龄：15
姓名：小李，年龄：16
姓名：小王，年龄：25
姓名：小李，年龄：16
END
