冰冻三尺非一日之寒
将自定义对象作为元素存到ArrayList集合中，并去除重复元素
* 程序头部注释开始
* 程序的版权和版本声明部分
* Copyright (c) 2011, 烟台大学计算机学院学生
* All rights reserved.
* 文件名称：将自定义对象作为元素存到ArrayList集合中，并去除重复元素
者：薛广晨
* 完成日期：2012
* 版 本号：x1.0
* 对任务及求解方法的描述部分
* 输入描述：
* 问题描述: 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
* 程序输出：
* 程序头部的注释结束
import java.util.*;
class Person
public Person(String name, int age)
this.name =
this.age =
public String getName()
return this.
public int getAge()
return this.
public void setName(String name)
this.name =
public void setName(int age)
this.age =
public boolean equals(Object obj)//重写equals方法
if(!(obj instanceof Person))
Person p = (Person)
return this.name.equals(p.name) && this.age == p.
class ArrayListTest2
public static void main(String[] args)
ArrayList al = new ArrayList();
al.add(new Person("lisi01",20));
al.add(new Person("lisi02",21));
al.add(new Person("lisi04",22));
al.add(new Person("lisi03",23));
al.add(new Person("lisi02",21));
al.add(new Person("lisi04",22));
sop("原集合：");
for(Iterator it = al.iterator(); it.hasNext();)
Person p = (Person) it.next();
sop("name:" + p.getName() + " :: age:" + p.getAge());
al = singleElement(al);
sop("新集合：");
for(Iterator it = al.iterator(); it.hasNext();)
Person p = (Person) it.next();
sop("name:" + p.getName() + " :: age:" + p.getAge());
public static ArrayList singleElement(ArrayList al)
ArrayList newAl = new ArrayList();
for(Iterator it = al.iterator(); it.hasNext();)
Object obj = it.next();
if(!newAl.contains(obj))
newAl.add(obj);
return newAl;
public static void sop(Object obj)
System.out.println(obj);
运行结果：
没有更多推荐了，Java基础语法
今日内容介绍
u&自定义类
u&ArrayList集合
第1章&引用数据类型（类）
1.1&引用数据类型分类
提到引用数据类型（类），其实我们对它并不陌生，如使用过的Scanner类、Random类。
我们可以把类的类型为两种：
l&第一种，Java为我们提供好的类，如Scanner类，Random类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。
l&第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。
这里我们主要介绍第二种情况的简单使用。
1.2&自定义数据类型概述
我们在Java中，将现实生活中的事物抽象成了代码。这时，我们可以使用自定义的数据类型（类）来描述（映射）现实生活中的事物。
类，它是引用数据类型，与之前学习的所有引用数据类型相同，自定义类也是一种数据类型。只是自定义类型并非Java为我们预先提供好的类型，而是我们自己定义的一种引用数据类型用来描述一个事物。
1.3&类的定义与使用
java代码映射成现实事物的过程就是定义类的过程。
我们就拿一部手机进行分析，它能用来做什么呢？它可以打电话，上网，聊微信等，这些就是手机所提供的功能，也就是方法；手机也有它的特征，如颜色、尺寸大小、品牌型号等，这些就是手机的特征，也就是属性。
目前，我们只关注类中的属性，类中的方法在面向对象部分再进行学习。
1.3.1&类的定义格式
l&类的定义格式
创建java文件，与类名相同
public class 类名{
数据类型 &属性名称1；
数据类型 &属性名称2；
通过类的定义格式，来进行手机类的描述，如下所示
public&class&Phone {
S// 品牌型号
double& // 尺寸大小
上述代码，就是创建一个类的的过程，类的名称我们给起名为Phone，类中包含了三个属性（brand品牌型号、color颜色、size尺寸大小）。注意，类中定义的属性没有个数要求。
1.3.2&类的使用格式
Phone类定义好后，我们就可以使用这个类了，使用方式和使用引用数据类型Scanner类相似。格式如下：
导包：我们将所有的类放到同一个文件夹下，可以避免导包。
创建对象：数据类型 &变量名 = new 数据类型();
调用方法：目前我们定义的自定义类不涉及方法，只是属性（自定义类中的方法部分在面向对象部分讲解）
访问属性：变量名.属性&(这是当前的方式，后期会采取调用方法的方式替代掉直接访问的方式来完成对属性的访问。)
当有了Phone数据类型的变量后，我们就可以使用Phone类中的属性了。对属性的访问我们来演示一下，如下所示：
public&class&Test {
public&static&void&main(String[] args) {
//定义了一个Phone类型的变量p
Phone p = new&Phone();
&* 通过p,使用Phone中的属性
//访问p中的brand品牌属性
p.brand&= "苹果6s";
//访问p中的color颜色属性
p.color&= "白色";
//访问p中的size尺寸大小属性
p.size&= 5.5;
System.out.println("手机品牌为"&+ p.brand);
System.out.println("手机颜色为"&+ p.color);
System.out.println("手机尺寸大小为"&+ p.size);
运行结果如下所示
图1-1&运行结果
1.3.3&自定义类型注意事项与内存图
上述代码中，通过类Phone创建出来的变量p，它相当于我们生活中的盒子，里面包含了它能够使用的属性。
l&通过 p.属性名 就可以对属性进行操作
l&与引用类型数组类似，引用类型的自定义类型的变量，直接变量时，结果为对象地址值，这里可以通过内存图简单解释。
1.4&自定义类型练习
学习了引用数据类型（类）以后，我们就能够使用类描述任何东西了。看几个具体的描述，如下：
l&电饭锅，包含属性（品牌、容量大小、颜色等）
l&汽车，包含属性（品牌、排量、类型等）
l&学生，包含属性（姓名，年龄，性别等）
第2章&ArrayList集合
在前面我们学习了数组，数组可以保存多个元素，但在某些情况下无法确定到底要保存多少个元素，此时数组将不再适用，因为数组的长度不可变。例如，要保存一个学校的学生，由于不停有新生来报道，同时也有学生毕业离开学校，这时学生的数目很难确定。为了保存这些数目不确定的元素，JDK中提供了一系列特殊的类，这些类可以存储任意类型的元素，并且长度可变，统称为集合。在这里，我们先介绍ArrayList集合，其他集合在后续课程中学习。
ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。
2.1&集合的创建
创建集合的常用格式在此说明一下：
导包：import java.util.ArrayL
创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
ArrayList&要存储元素的数据类型& 变量名 = new ArrayList&要存储元素的数据类型&();
l&集合中存储的元素，只能为&&括号中指定的数据类型元素；
l&“&要存储元素的数据类型&”中的数据类型必须是引用数据类型，不能是基本数据类型；
下面给出8种基本数据类型所对应的引用数据类型表示形式:
基本数据类型
对应的引用数据类型表示形式
我们通过举几个例子，来明确集合的创建方式：
l&存储String类型的元素
ArrayList&String& list = new ArrayList&String&();
l&存储int类型的数据
ArrayList&Integer& list = new ArrayList&Integer&();
l&存储Phone类型的数据
ArrayList&Phone& list = new ArrayList&Phone&();
2.2&集合中常用方法
接下来，我们来学习下ArrayList集合提供的一些常用方法，如下表：
boolean add（Object obj）
将指定元素obj追加到集合的末尾
Object get（int index）
返回集合中指定位置上的元素
int size（）
返回集合中的元素个数
通过代码演示上述方法的使用。ArrayListDemo01.java
import&java.util.ArrayL
public&class&ArrayListDemo01 {
public&static&void&main(String[] args) {
// 创建ArrayList集合
ArrayList&String& list = new&ArrayList&String&();
// 向集合中添加元素
list.add("stu1");
list.add("stu2");
list.add("stu3");
list.add("stu4");
// 获取集合中元素的个数
System.out.println("集合的长度："&+ list.size());
// 取出并打印指定位置的元素
System.out.println("第1个元素是："&+ list.get(0));
System.out.println("第2个元素是："&+ list.get(1));
System.out.println("第3个元素是："&+ list.get(2));
System.out.println("第4个元素是："&+ list.get(3));
强调一点，ArrayList集合相当于是一个长度可变的数组，所以访问集合中的元素也是采用索引方式访问，第一个元素存储在索引0的位置，第二个元素存储在索引1的位置，依次类推。
2.3&集合的遍历
通过集合遍历，得到集合中每个元素，这是集合中最常见的操作。集合的遍历与数组的遍历很像，都是通过索引的方式，集合遍历方式如下：ArrayListDemo02.java
1&import&java.util.ArrayL
2&public&class&ArrayListDemo02 {
3& public&static&void&main(String[] args) {
4& //创建ArrayList集合
5& ArrayList&Integer& list = new&ArrayList&Integer&();
6& //添加元素到集合
7& list.add(13);
8& list.add(15);
9& list.add(22);
10& list.add(29);
11& //遍历集合
12& for&(int&i = 0; i & list.size(); i++) {
13& //通过索引，获取到集合中每个元素
14& int&n = list.get(i);
15& System.out.println(n);
上述代码中，第5行定义了一个可以存储int元素的集合；第7-10行，实现将int类型数值存储到集合中；第12-16行，实现遍历集合元素。这里要强调一点，get方法返回值的类型为集合中元素的类型。
2.4&集合中的常用方法补充
ArrayList集合提供的一些常用方法，如下表：
boolean add（int index, &Object obj）
将指定元素obj插入到集合中指定的位置
Object&remve（int index）
从集合中删除指定index处的元素，返回该元素
void&clear（）
清空集合中所有元素
Object set（int index, Object obj）
用指定元素obj替代集合中指定位置上的元素
l&boolean add（int index, &Object obj）
l&功能：在集合中指定index位置，添加新元素obj
l&功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用add(1，“javaWeb”)后，集合list中的元素为[“java”,“javaWeb”,“JavaEE”]。
l&Object set（int index, Object obj）
l&功能：用指定元素obj替代集合中指定index位置的元素
l&功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用set(0，“javaWeb”)后，集合list中的元素为[“javaWeb”,“JavaEE”]。
l&Object&remve（int index）
l&功能：从集合中删除指定index处的元素，返回该元素
l&功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用remove(0)后，集合list中的元素为[“JavaEE”]，返回值为“java”。
l&void&clear（）
l&功能：清空集合中所有元素
l&功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用clear()后，集合list中的元素为空[]。
第3章&随机点名器案例
3.1&案例介绍
随机点名器，即在全班同学中随机的找出一名同学，打印这名同学的个人信息。
此案例在我们昨天课程学习中，已经介绍，现在我们要做的是对原有的案例进行升级，使用新的技术来实现。
我们来完成随机点名器，它具备以下3个内容：
l&存储所有同学姓名
l&总览全班同学姓名
l&随机点名其中一人，打印到控制台
3.2&案例需求分析
全班同学中随机的找出一名同学，打印这名同学的个人信息。
我们对本案例进行分析，得出如下分析结果：
1.存储全班同学信息（姓名、年龄）
2.打印全班同学每一个人的信息（姓名、年龄）
3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学信息（姓名、年龄）
随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。
而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们采用ArrayList集合来解决多个学生信息的存储问题。
3.3&实现代码步骤
每名学生都拥有多项个人信息，为了方便管理每个人的信息，我们对学生信息进行封装，编写Student.java文件
&* 学生信息类
public&class&Student {
int& //年龄
上述代码中，对学生信息（姓名、年龄）进行了封装。这样做的好处在于，以后只要找到这名学生，就能够知道他的每项个人信息了。
接下来我们编写CallName.java文件，完成程序的编写。
l&main方法中调用三个独立方法
public&static&void&main(String[] args) {
ArrayList&Student& list = new&ArrayList&Student&(); //1.1创建一个可以存储多个同学名字的容器
&* 1.存储全班同学信息
addStudent(list);
&* 2.打印全班同学每一个人的信息（姓名、年龄）
printStudent(list);
&* 3.随机对学生点名，打印学生信息
randomStudent(list);
l&存储所有学生的个人信息
&* 1.存储全班同学名字
public&static&void&addStudent(ArrayList&Student& list) {
//键盘输入多个同学名字存储到容器中
Scanner sc = new&Scanner(System.in);
for&(int&i = 0; i & 3; i++) {
//创建学生
Student s = new&Student();
System.out.println("存储第"+i+"个学生姓名：");
s.name&= sc.next();
System.out.println("存储第"+i+"个学生年龄：");
s.age&= sc.nextInt();
//添加学生到集合
list.add(s);
上述方法中，方法参数list中用来表示已存储所有学生。通过Scanner，完成新学生信息（姓名，年龄）的录入，并将学生添加到集合中。
l&打印全班同学每一个人的信息
&* 2.打印全班同学每一个人的信息（姓名、年龄）
public&static&void&printStudent (ArrayList&Student& list) {
for&(int&i = 0; i & list.size(); i++) {
Student s = list.get(i);
System.out.println("姓名："+s.name&+",年龄："+s.age);
上述方法中，方法参数list中用来表示已存储所有学生。通过遍历集合中的每个元素，得到每个同学信息，并输出打印。
l&随机对学生点名，打印学生信息
&* 3.随机对学生点名，打印学生信息
public&static&void&randomStudent (ArrayList&Student& list) {
//在班级总人数范围内，随机产生一个随机数
int&index = new&Random().nextInt(list.size());
//在容器（ArrayList集合）中，查找该随机数所对应的同学信息（姓名、年龄）
Student s = list.get(index);
System.out.println("被随机点名的同学："+s.name&+ "，年龄:"&+ s.age);
上述方法中，通过随机数类Random产生一个从0到集合长度的随机索引。使用该索引获取ArrayList集合中对应的值，便得到了全班同学的随机学生信息并打印。
第4章&库存管理案例
4.1&案例介绍
现在，我们将原有的库存管理案例，采用更好的集合方式实现。
将对下列功能进行方法封装：
l&打印库存清单功能
l&库存商品数量修改功能
l&退出程序功能
4.2&案例需求分析
管理员能够进行的操作有3项（查看、修改、退出），我们可以采用（switch）菜单的方式来完成。
-------------库存管理------------
1.查看库存清单
2.修改商品库存数量
请输入要执行的操作序号：
& 每一项功能操作，我们采用方法进行封装，这样，可使程序的可读性增强。
选择“1.查看库存清单”功能，则控制台打印库存清单
选择“2.修改商品库存数量”功能，则对每种商品库存数进行更新
选择“3.退出”功能，则退出库存管理，程序结束
4.3&实现代码步骤
每种库存商品都拥有多项商品信息，为了方便管理每种商品的信息，我们对商品信息进行封装，编写Goods.java文件
&* 库存商品类
public&class&Goods {
S // 商品品牌型号
double& // 商品尺寸大小
double& // 商品价格
int& // 商品库存个数
上述代码中，对商品信息（品牌、尺寸、价格、库存数）进行了封装。这样做的好处在于，以后只要找到这个商品，就能够知道该商品的每项信息了。
编写Demo库存管理.java，完成如下功能：
l&功能菜单
&* 库存管理功能菜单
&* @return&管理员键盘输入的功能操作序号
public&static&int&chooseFunction() {
System.out.println("-------------库存管理------------");
System.out.println("1.查看库存清单");
System.out.println("2.修改商品库存数量");
System.out.println("3.退出");
System.out.println("请输入要执行的操作序号：");
//接收键盘输入的功能选项序号
Scanner sc = new&Scanner(System.in);
int&choose = sc.nextInt();
上述方法用来完成库存管理功能菜单的显示、接收管理员选择的功能操作序号。这是完成了案例的第一步。接下来完成“查看、修改、退出”这三项功能。
l&编写main主方法，调用库存管理功能菜单方法，与“查看、修改、退出”这三个方法。
public&static&void&main(String[] args) {
//记录库存商品信息
ArrayList&Goods& list = new&ArrayList&Goods&();
//添加商品到库存
addStore(list);
//通过while循环模拟管理员进行功能重复选择操作
while&(true) {
//打印功能菜单操作,接收键盘输入的功能选项序号
int&choose = chooseFunction();
//执行序号对应的功能
switch&(choose) {
case&1://查看库存清单
printStore(list);
case&2://修改商品库存数量
update(list);
case&3://退出
System.out.println("----------------------------------");
System.out.println("功能选择有误，请输入正确的功能序号!");
在主方法中，创建了ArrayList集合，用来存储库存商品信息，通过接收到的功能选项序号，进行switch语句判断后，调用对应的功能方法。
l&查看库存清单功能
&* 查看库存清单
public&static&void&printStore(ArrayList&Goods& list) {
//统计总库存个数、统计库存总金额
int&totalCount = 0;
double&totalMoney = 0.0;
//列表顶部
System.out.println("---------------------------查看库存清单--------------------------");
System.out.println("品牌型号 尺寸 价格 库存数");
//列表中部
for&(int&i = 0; i & list.size(); i++) {
Goods item = list.get(i);
System.out.println(item.brand+" "+item.size+" "+item.price+" "+ item.count);
//统计总库存个数、统计库存总金额
totalCount += item.
totalMoney += item.count&* item.
//列表底部
System.out.println("-------------------------------------------------------------");
System.out.println("总库存数："+totalCount);
System.out.println("库存商品总金额："+totalMoney);
上述方法用来完成打印库存清单功能，参数list表示库存商品相关信息集合。
l&修改商品库存数量功能
&* 修改商品库存数量
public&static&void&update(ArrayList&Goods& list){
System.out.println("------------修改商品库存数量-----------");
for&(int&i = 0; i & list.size(); i++) {
Goods item = list.get(i);
System.out.println("请输入"+ item.brand&+"商品库存数量");
item.count&= new&Scanner(System.in).nextInt();
list.set(i, item);
上述方法用来完成修改商品库存数量功能，参数list表示库存商品相关信息集合。
l&退出功能
public&static&void&exit(){
System.out.println("----------------退出---------------");
System.out.println("您已退出系统");
上述方法用来完成退出程序的功能
第5章&总结
5.1&知识点总结
l&引用数据类型（类）
l&类的类型为两种：
l&第一种，Java为我们提供好的类，如Scanner类，Scanner类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。
l&第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。
l&创建类的格式
public class 类名 {
&&&&&&&&&&&&&&//可以定义属性
&&&&&&&&&&&&&&//也可以定义方法
l&使用类的格式：
类名 变量名 = new 类名();
l&使用类中的属性与方法格式
使用属性： 变量名.属性
使用方法： 变量名.方法()
l&ArrayList集合
l&它属于引用数据类型（类）。我们可以看作一个长度可变的数组。
l&创建集合的方式
ArrayList&要存储元素的数据类型& 变量名 = new ArrayList&要存储元素的数据类型&();
l&集合中的常用方法
l&boolean add（Object obj）
l&Object get（int index）
l&int size（）
l&boolean add（int index, &Object obj）
l&Object set（int index, Object obj）
l&Object&remve（int index）
l&void&clear（）
阅读(...) 评论()封装ArrayList
转载请注明出处
http://blog.csdn.net/pony_maggie/article/details/
ArrayList很好用，可以添加任意类型，动态增长，各种库函数支持，如下是个简单示例:
public class FillingList {
* @param args
* fill只会对已经存在空间填充，所以下面的for循环必不可少
public static void main(String[] args)
// TODO Auto-generated method stub
List&String& list = new ArrayList&String&();
for (int i = 0; i & 10; i++)
list.add("");
Collections.fill(list, "hello");
System.out.println(list);
} 它存在一个问题，就是不知道add进来的类型。因为add方法本身接受的是Object类型,当我们取出来列表中的内容使用时，需要强制转换实际的类型，如下所示:
public static void main(String[] args)
ArrayList cats = new ArrayList();
for(int i = 0; i & 7; i++)
cats.add(new Cat(i));
for(int i = 0; i & 7; i++)
((Cat)cats.get(i)).print();
} 如果程序员忘记了原来add进来的类型，然后在get的时候，转换成错误的实际类型了，就像下面这样，会怎样呢？public class CatsAndDogs
* @param args
public static void main(String[] args)
ArrayList cats = new ArrayList();
for(int i = 0; i & 7; i++)
cats.add(new Cat(i));
cats.add(new Dog(7));
for(int i = 0; i & 7; i++)
((Cat)cats.get(i)).print();
for(int i = 0; i & cats.size(); i++)
((Cat)cats.get(i)).print();
//dog is detected at run time
答案是编译没有问题，运行时才会报错。这样就会有很大的风险。
所以需要对ArrayList进行封装
public class AutoArrayList extends ArrayList{
private Class itemC
public AutoArrayList(Class itemClass){
this.itemClass = itemC
public Object get(int index){
while(index&=size()){
add(itemClass.newInstance());
}catch(Exception e){
e.printStackTrace();
return super.get(index);
没有更多推荐了，Oh boy, so I've spent the last hour or so reading and trying different ways of storing an ArrayList of a Parcelable Object in the Android preferences and Local Storage, and now I'm back to square one. I have downloaded and imported Gson, by the way, not that I could get it to work.
Basically, I have a class called Task in an ArrayList&& called taskList that I need to save even when my users close my app. The Object consists of a String, some Ints, some Booleans and an ArrayList of class Subtask if that matters. What's important is that it seems I can't just write it as a list of Strings, and all the tutorials I've found only show saving simple ArrayLists like Strings and they have all been Serializable, not Parcelable.
EDIT: thanks for the suggestions, but I implement Parcelable to parcel specific objects in the list between activities..
解决方案 According to ,
Parcelable: Interface for classes whose instances can be written to and restored from a Parcel.
And reading in :
Parcel is not a general-purpose serialization mechanism. This class (and the corresponding Parcelable API for placing arbitrary objects into a Parcel) is designed as a high-performance IPC transport. As such, it is not appropriate to place any Parcel data in to persistent storage: changes in the underlying implementation of any of the data in the Parcel can render older data unreadable.
So if you want to store all the references of different types by an ArrayList you must wrap all the objects to a common interface, in this case
is your friend.
Also, according your question:
I need to save even when my users close my app.
If you check the android lifecycle, you will see you need to perform this action in , which is called when your activity is no longer visible to the user.
ADDITIONAL INFO from
Setting values in Preference:
// MY_PREFS_NAME - a static String variable like:
//public static final String MY_PREFS_NAME = "MyPrefsFile";
SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit();
editor.putString("name", "Elena");
editor.putInt("idName", 12);
editor.commit();
Retrieve data from preference:
SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE);
String restoredText = prefs.getString("text", null);
if (restoredText != null) {
String name = prefs.getString("name", "No name defined");//"No name defined" is the default value.
int idName = prefs.getInt("idName", 0); //0 is the default value.
more info:
本文地址： &
哦，那个男孩，所以我花了最近一个小时左右的时间阅读并试图存储 Parcelable Object 的 ArrayList
code>在Android偏好设置和本地存储中，现在我又回到原点了。顺便说一下，我已经下载并导入了Gson，并不是说我可以让它工作。
基本上，我在 ArrayList&&中有一个名为 Task
code>称为 taskList ，即使当我的用户关闭我的应用程序时，我也需要保存它。
Object 包含一个字符串，一些 Ints ，一些布尔值和一个类别子任务的ArrayList 。重要的是，我似乎不能把它写成一个字符串列表，我发现的所有教程都只显示保存简单的ArrayLists，比如字符串，它们都是可序列化的，而不是可分段的。
编辑：感谢您的建议，但我实现了Parcelable来包裹活动中列表中的特定对象..
解决方案 根据，
Parcelable：类的实例可以写入 Parcel 。
地块不是通用序列化机制。这个类（和相应的用于将任意对象放入Parcel的Parcelable API）被设计为高性能IPC传输。因此，将任何Parcel数据放入持久性存储中是不恰当的：Parcel中任何数据的底层实现的更改都会导致旧数据无法读取。
所以如果你想通过 ArrayList 存储所有不同类型的引用，你必须将所有的对象包装到一个通用接口中， 是你的朋友。
另外，根据您的问题：
即使我的用户关闭，我也需要保存我的应用程序。
如果您检查android生命周期，您将看到您需要在，当您的活动对用户不再可见时调用它。
其他信息来自
在首选项中设置值：
// MY_PREFS_NAME
- 静态字符串变量，如： // public static final String MY_PREFS_NAME =“MyPrefsFile”;
SharedPreferences.Editor编辑器= getSharedPreferences（MY_PREFS_NAME，MODE_PRIVATE）.edit（）;
editor.putString（“name”，“Elena”）;
editor.putInt（“idName”，12）;
editor.commit（）;
从首选项中检索数据：
SharedPreferences prefs = getSharedPreferences（MY_PREFS_NAME，MODE_PRIVATE）; 字符串restoredText = prefs.getString（“text”，null）;
if（restoredText！= null）{ String name = prefs.getString（“name”，“No name defined”）; //“No name defined”是默认值。
int idName = prefs.getInt（“idName”，0）; // 0是默认值。
$ / code $ / pre
本文地址： &
扫一扫关注IT屋
微信公众号搜索 “ IT屋 ” ，选择关注
与百万开发者在一起
(window.slotbydup = window.slotbydup || []).push({
id: '5828425',
container: s,
size: '300,250',
display: 'inlay-fix'