标签：方法 ret -- mamicode hash 就是 数据处理 img 判断
1. 尝试使用
接口指定规范，完成数据展示过滤功能
例如:
只要学生成绩50分以上
只要学生年龄16岁以下...
方法名要求
accept
2. 完成数据的字符串处理过程
数据 ==> 字符串 字符串 ==> 数据
分析需要完成的方法
该方法是在遍历展示学生数据的过程中完成的。存在一个判断
for(遍历保存数据的数组) {
if (条件过滤) {
展示
}
}
返回值类型:
boolean
方法名:
accept
形式参数列表:
一个Student学生类对象
interface StudentFilter {
boolean accept(Student stu);
}
package com.qfedu.student.system.filter;
import com.qfedu.student.system.entity.Student;
public interface StudentFilter {
/**
* 判断一个Student类对象是否能够满足条件，满足条件返回true，否则返回false
* 条件判断由接口实现类完成
*
* @param student Student类对象
* @return 满足条件返回true，不满足返回false
*/
boolean accept(Student student);
}
package com.qfedu.student.system.filter.impl;
import com.qfedu.student.system.entity.Student;
import com.qfedu.student.system.filter.StudentFilter;
public class StudentFilterImpl implements StudentFilter {
@Override
public boolean accept(Student student) {
return student.getScore() > 50 && student.getAge() > 100;
}
}
开发中数据的存储是很大一部分内容。
马云爸爸 得数据者得天下！！！
程序数据 ==> 字符串 ==> 文件
文件 ==> 字符串 ==> 程序数据
Student [id=11, name=骚磊, age=166, gender=男, score=60]
数据
11 骚磊 166 男 60
每一个数据都有对应的指向性
数据对应的名称不需要保存
但是！！！
需要约束好数据的存储和解析规范。
类似于真实开发场景中的接口概念，也就是规范化数据传输格式！！！
保存数据
11 骚磊 166 男 60 ==> 11,骚磊,166,男,60 ==> String
+ 万能胶水
/**
* 获取Student类对象中数据的字符串形式
*
* @return Student信息字符串
*/
public String getStudentData() {
return id + "," + name + "," + age + "," + gender + "," + score;
}
字符串
11,骚磊,166,男,60
==> Student 对象
1. split(",")
==> String类型的数组{"11", "骚磊", "166", "男", "60"}
2. id age score ==> int类型
3. 包装类
Byte Short Integer Long Float Double Character Boolean
【解析方法】
存在将字符串数据 ==> 对应类型的方法。
方法
放在那里？？？那里类内？？？
目前该方法存放在Student类内，暂时存放，后期考虑完成一个数据处理类(DAO)
方法权限修饰符
public √
private 不可以
是否需要使用static修饰
成员方法
需要通过类对象来进行操作解析完成
该方法使用场景是在代码的启动阶段从文件中读取字符串数据之后，解析字符
串内容
静态成员方法 √
通过类名直接调用，做成一个工具方法，操作更加方便，摆脱类对象约束
返回值类型:
Student
方法名:
parseStudent
形式参数列表:
String str
方法声明:
public static Student parseStudent(String str);
/**
* 解析学生信息字符串，转换成一个Student类对象返回
*
* @param str 包含Student信息指定格式字符串
* @return Student类对象
*/
public static Student parseStudent(String str) {
// "11,骚磊,166,男,60"
// 1. split 按照逗号分隔
String[] split = str.split(",");
// {"11","骚磊","166","男","60"}
// Integer.parseInt(String str) 字符串 ==> int类型数据
int id = Integer.parseInt(split[0]);
String name = split[1];
int age = Integer.parseInt(split[2]);
char gender = split[3].charAt(0);
int score = Integer.parseInt(split[4]);
/*
Float.parseFloat(s)
Double.parseDouble(s)
Boolean.parseBoolean(s)
*/
return new Student(id, name, age, gender, score);
}
目前代码中对于多个数据处理过程中，我们采用的方式是数组方式。
数组操作存在的问题:
1. 复用度差！！！
目前对于数据操作有且只能支持一个数据类型，一旦需要操作其他类型，全部
重构，从头来过
2. 空间固定！！！
数组的空间一旦在创建过程中确定，空间无法修改。
3. 方法较少！！！
add remove modify get 。。。
自己写的！！！方法自己实现，体验不好！！！Java中对于数组操作没有提供
太多的有效方法
以上问题集合都可以解决！！！
1. 复用性，没有问题！！！
集合创建采用了泛型模式，可以用户指定任意类型操作！！！既满足普适性，又满足数据类型一致化要求
2. 空间在合理范围以内自行扩展，不需要考虑容量问题
3. 方法很多！！！操作性很好！！！
interface Collection<E> Java中所有集合的总接口
--| interface List<E> List接口，数据存储可重复，有序。
----| class ArrayList<E>
重点 可变长数组
----| class LinkedList<E>
重点 双向链表模式
----| class Vector<E>
线程安全的可变长数组
--| interface Set<E> Set接口，数据存储不可以重复，无序
----| HashSet<E>
底层存储数据的结构是一个哈希表，存储效率，查询效率极高！！！
----| TreeSet<E>
底层存储数据的结构是一个平衡二叉树结构，要求数据必须有比较方式！！！
增：
boolean add(E e)
添加当前集合约束的指定数据类型到当前集合中
boolean addAll(Collection<? extends E> c);
添加另一个集合到当前集合中，要求添加集合中保存的元素必须是当前集合中保存
元素本身或者其子类对象 【泛型的上限】
class Dog extends Animal
class Cat extends Animal
class Tiger extends Animal
删：
boolean remove(Object obj);
删除集合中的指定元素，删除成功返回true,未找到指定元素，无法删除返回
false，并且在多个元素的情况下，删除找到的第一个元素。
boolean removeAll(Collection<?> c);
在当前集合中删除两个集合的交集
boolean retainAll(Collection<?> c);
在当前集合中保留两个集合的交集
void clear();
清空整个集合中的所有元素
查：
int size();
有效元素个数
boolean isEmpty();
判断当前集合是否为空，是否存在有效元素
boolean contains(Object obj);
判断指定元素是否在当前集合中存在
boolean containsAll(Collection<?> c);
判断传入的参数集合是不是当前集合的子集合
Object[] toArray();
返回集合中所有保存元素的Object类型数组
问题:
<? extends E>
class Animal
--| class Dog extends Animal
--| class Cat extends Animal
--| class Tiger extends Animal
? 替代Dog Tiger
E ==> Animal
? 是泛型的通配符
package com.qfedu.a_collection;
import java.util.ArrayList;
import java.util.Collection;
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
class Flower {}
/*
* 泛型上限演示
*/
public class Demo3 {
public static void main(String[] args) {
Collection<Animal> c1 = new ArrayList<Animal>();
Collection<Dog> c2 = new ArrayList<Dog>();
Collection<Cat> c3 = new ArrayList<Cat>();
Collection<Flower> c4 = new ArrayList<Flower>();
Collection<Object> c5 = new ArrayList<Object>();
/*
* 当前方法所需的参数类型是Collection<? extends Animal>
*
* 要求参数是一个Collection集合
* 要求Collection集合中保存的元素是Animal本身或者其子类对象
*/
c1.addAll(c1);
c1.addAll(c2);
c1.addAll(c3);
/*
* c4 对应的数据类型是Collection<Flower>
* 满足当前方法所需数据类型必须是Collection集合，但是不满足
* 当前集合中保存元素是Animal本身或者其子类对象的需求。参数错误。
*/
// c1.addAll(c4);
/*
* c5 对应的数据类型是Collection<Object>
* 满足参数要求为Collection集合，但是存储元素是Object类型
* 不是Animal的子类
*/
// c1.addAll(c5);
c1.add(new Animal());
c1.add(new Dog());
c1.add(new Cat());
System.out.println(c1);
}
}
boolean removeAll(Collection<?> c);
在当前集合中删除两个集合的交集
boolean retainAll(Collection<?> c);
在当前集合中保留两个集合的交集
boolean containsAll(Collection<?> c);
判断传入的参数集合是不是当前集合的子集合
? 在当前情况下描述的场景为，不限制传入参数Collection集合中的保存元素。
这里只要求参数类型是Collection，里面保存元素无所谓
迭代器是操作集合中元素的第二种方式，后期可以延展使用到很多地方，并且存在一个升级版内容。【增强for循环】
迭代器和集合本身有着密切关系，首先迭代器的获取，就是通过集合对象得到对应当前集合的迭代器。
获取迭代器方法:
Iterator<E> iterator();
获取迭代器对象，泛型对应的具体数据类型和集合中约束的泛型具体数据类型
一致。
迭代器操作使用到的方法：
boolean hasNext();
判断当前集合中是否可以继续得到元素，继续遍历。
E next();
1. 获取迭代器当前指向的元素
2. 将迭代器指向下一个元素
void remove();
删除通过next方法获取到元素
【注意事项】
1. remove方法只能删除next方法获取到元素
2. remove方法只能在next方法之后执行，且不能跨过一个next执行
3. 没有next不能使用remove
package com.qfedu.b_iterator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 迭代器操作
*/
public class Demo1 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("雪花纯生");
c.add("修道院啤酒");
c.add("1664");
c.add("泰山精酿");
c.add("时光精酿");
System.out.println(c);
/*
* 获取对应当前集合的迭代器对象
* 集合中保存元素是什么类型，迭代器操作元素就是什么类型
*
* 迭代器在获取的过程中，默认指向集合中的第一个元素
*/
Iterator<String> iterator = c.iterator();
System.out.println("hasNext()方法演示:" + iterator.hasNext());
System.out.println("next()方法演示:" + iterator.next());
System.out.println("next()方法演示:" + iterator.next());
System.out.println("remove()执行");
// 指向迭代器remove方法
iterator.remove();
// iterator.remove();
System.out.println(c);
}
}
package com.qfedu.b_iterator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo2 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("雪花纯生");
c.add("修道院啤酒");
c.add("1664");
c.add("泰山精酿");
c.add("时光精酿");
/*
* 获取当前集合的迭代器对象
*/
Iterator<String> iterator = c.iterator();
while (iterator.hasNext()) {
String string = iterator.next();
System.out.println(string);
iterator.remove();
}
System.out.println(c);
System.out.println(c.isEmpty());
}
}
package com.qfedu.b_iterator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo3 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("雪花纯生");
c.add("修道院啤酒");
c.add("1664");
c.add("泰山精酿");
c.add("时光精酿");
/*
* 根据当前集合，获取对应的迭代器对象
*
* 得到的迭代器对象会依据，当前集合中的所有元素进行一个规划操作。
* 迭代器对于整个集合中的元素都是存在预期。
*/
Iterator<String> iterator = c.iterator();
/*
* 迭代器遍历，利用迭代器的特征进行遍历操作
*/
while (iterator.hasNext()) {
// 获取每一个迭代器指向元素，并且展示
String string = iterator.next();
System.out.println(string);
/*
* 通过集合对象本身删除1664，对于迭代器而言，一脸懵逼，原本的规划
* 没有了！！！并且集合没有告知迭代器数据发生了改变，迭代器继续按照
* 原本的规划路径操作，保存！！！
*
* 对于集合在内存中占用的空间而言
* 1. 集合对应的引用数据类型变量可以操作对应空间
* 2. 迭代器可以操作对应的空间
*
* 对于集合和迭代器而言，【集合在内存中占用的空间】共享资源，在操作
* 共享资源过程中，我们要多多考虑共享资源的冲突问题。
* 后面课程中会讲到【多线程】
*/
c.remove("1664");
}
/*
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at com.qfedu.b_iterator.Demo3.main(Demo3.java:30)
*/
}
}
标签：方法 ret -- mamicode hash 就是 数据处理 img 判断
原文地址：https://www.cnblogs.com/raising/p/12892062.html
