关于java:我在上海乐字节学习Java的第二十天持续更新中

Java 汇合（上）

Java 中的汇合是工具类，能够存储任意数量的具备独特属性的对象

为什么应用汇合，而不必数组呢？
– 存储 20 名学生信息（数组）
– 存储商品信息（汇合）
利用场景
无奈预测存储数据的数量
同时存储具备一对一关系的数据
须要进行数据的增删
数据反复问题

List 是元素有序并且能够反复的汇合，称为序列
List 能够准确的管制每个元素的插入地位，或删除某个地位的元素
List 的两个次要实现类是 ArrayList 和 LinkedList

ArrayList 底层是由数组实现的
动静增长，以满足应用程序的需要
在列表尾部插入或删除十分无效
更适宜查找和更新元素
ArrayList 中的元素能够为 null

汇合是属于 java.util 包的（想要具体理解能够查找 API 文档，上面我全副列举）
Collection

List

ArrayList

用 ArrayList 存储编程语言的名称，并输入
名称包含“Java”、“C”、“C++”、“Go”和“Swift”
具体用到了 add()、size()、remove(int index)、remove(Object o) 办法

package com.sh.set;
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
// 用 ArrayList 存储编程语言的名称，并输入
List list=new ArrayList();
list.add(“Java”);
list.add(“C”);
list.add(“C++”);
list.add(“Go”);
list.add(“swift”);
// 输入列表中元素的个数
System.out.println(“ 列表中元素的个数为：”+list.size());
// 遍历输入所有编程语言
System.out.println(“**”);
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+”,”);
}
// 移除列表中的 C ++
System.out.println();
list.remove(2);
// list.remove(“C++”);
System.out.println(“**”);
System.out.println(“ 移除 C ++ 当前的列表元素为：”);
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+”,”);
}
}
}

在内存中的存储办法

运行后果

需要
– 布告的增加和显示
– 在指定地位处插入布告
– 删除布告
– 批改布告
布告类属性
– 编号 id
– 题目 title
– 创建人 creator
– 创立工夫 createTime
布告类办法
–构造方法
–获取和设置属性值的办法
所用办法
– add(int index, E element) 在列表的指定地位插入指定元素
– remove(int index) 移除列表中指定地位的元素
– set(int index, E element) 用指定元素替换列表中指定地位的元素

package com.sh.set;
import java.util.Date;
public class Notice {
private int id;//ID
private String title;// 题目
private String creator;// 创建人
private Date createTime;// 创立工夫
public Notice(int id, String title, String creator, Date createTime) {
super();
this.id = id;
this.title = title;
this.creator = creator;
this.createTime = createTime;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getCreator() {
return creator;
}
public void setCreator(String creator) {
this.creator = creator;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
// 测试类
package com.sh.set;
import java.util.ArrayList;
import java.util.Date;
public class NoticeTest {
public static void main(String[] args) {
// 创立 Notice 类的对象，生成三条布告
Notice notice1 = new Notice(1, “ 欢送来到学习网！”, “ 管理员 ”, new Date());
Notice notice2 = new Notice(2, “ 请同学们按时提交作业！”, “ 老师 ”, new Date());
Notice notice3 = new Notice(3, “ 考勤告诉！”, “ 老师 ”, new Date());
// 增加布告
ArrayList noticeList = new ArrayList();
noticeList.add(notice1);
noticeList.add(notice2);
noticeList.add(notice3);
// 显示布告
System.out.println(“ 布告的内容为：”);
for (int i = 0; i < noticeList.size(); i++) {
System.out.println(i + 1 + “:” + ((Notice) (noticeList.get(i))).getTitle());
}
System.out.println(“ 工夫：”+((Notice)(noticeList.get(1))).getCreateTime());
System.out.println(“**”);
// 在第一条布告前面增加一条新布告
Notice notice4 = new Notice(4, “ 在线编辑器能够应用啦！”, “ 管理员 ”, new Date());
noticeList.add(1, notice4);
// 显示布告
System.out.println(“ 布告的内容为：”);
for (int i = 0; i < noticeList.size(); i++) {
System.out.println(i + 1 + “:” + ((Notice) (noticeList.get(i))).getTitle());
}
System.out.println(“**”);
// 删除按时提交作业的布告
noticeList.remove(2);
// 显示布告
System.out.println(“ 删除布告后的内容为：”);
for (int i = 0; i < noticeList.size(); i++) {
System.out.println(i + 1 + “:” + ((Notice) (noticeList.get(i))).getTitle());
}
// 将第二条布告改为：Java 在线编辑器能够应用啦！
System.out.println(“**”);
// 批改第二条布告中 title 的值
notice4.setTitle(“Java 在线编辑器能够应用啦！”);
noticeList.set(1, notice4);
System.out.println(“ 批改后布告的内容为：”);
for (int i = 0; i < noticeList.size(); i++) {
System.out.println(i + 1 + “:” + ((Notice) (noticeList.get(i))).getTitle());
}
}
}

运行后果

与 ArrayList 一样，LinkedList 也依照索引地位排序，但它的元素之间是双向链接的
适宜疾速地插入和删除元素
LinkedList 实现 List 和 Queue 两个接口

构造方法

package com.sh.set;
import java.util.LinkedList;
public class LinkedListDemo1 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<String>();
// 向链表增加数据
list.add(“apple”);
list.add(“pear”);
// 将数据增加到链表的开始
list.addFirst(“banana”);
// 将数据增加到链表的开端
list.addLast(“grape”);
// 在指定地位处增加数据，第一个参数为 index 值，从 0 开始
list.add(2, “orange”);
// 显示链表中的所有数据
System.out.println(list);
// 判断列表中是否蕴含指定的元素，并输入相应的后果
boolean flag = list.contains(“grape”);
if (flag) {
System.out.println(“grape 找到了！”);
} else {
System.out.println(“grape 没找到！”);
}
// 返回 index 值为 3 的数据并输入
System.out.println(“index 值为 3 的数据为：” + list.get(3));
// 返回第一个元素
System.out.println(“ 第一个元素为：” + list.getFirst());
// 返回最初一个元素
System.out.println(“ 最初一个元素为：” + list.getLast());
}
}

运行后果

Student 类
package com.sh.set;
public class Student {
private String stuNum;
private String stuName;
private int age;
public Student(String stuNum, String stuName, int age) {
this.stuNum = stuNum;
this.stuName = stuName;
this.age = age;
}
public String getStuNum() {
return stuNum;
}
public void setStuNum(String stuNum) {
this.stuNum = stuNum;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return ” [学号：” + stuNum + “, 姓名：” + stuName + “, 年龄：” + age + “]”;
}
}
LinkedListDemo2 类
package com.sh.set;
import java.util.LinkedList;
public class LinkedListDemo2 {
public static void main(String[] args) {
LinkedList<Student> stuList = new LinkedList<Student>();
Student stu1 = new Student(“001”, “Mike”, 18);
Student stu2 = new Student(“002”, “Jack”, 20);
Student stu3 = new Student(“003”, “Lucy”, 19);
// 将学生增加到链表，应用 push 实现
// LinkedList 实现 List 接口的同时，也实现了 Queue 接口
// push 和 pop 就是针对 Queue 进行增加和取出数据的操作的
stuList.push(stu1);
stuList.push(stu2);
stuList.push(stu3);
System.out.println(“ 链表为：” + stuList);
// 弹出一个元素，这里能够把链表看成一个容器，先退出到链表的数据后弹出，
// 根据的准则是先进后出
System.out.println(“ 弹出的数据为：” + stuList.pop());
System.out.println(“ 调用 pop()办法后的链表为：n” + stuList);
// peek()办法获取并不移除元素
System.out.println(“ 调用 peek()办法的数据为：” + stuList.peek());
System.out.println(“ 调用 peek()办法后的链表为：n” + stuList);
// 再次调用 pop()办法，发现调用 pop()办法后数据从链表中移除了，而 peek()办法不会
System.out.println(“ 再次调用 pop()办法 ” + stuList.pop());
System.out.println(“ 再次调用 pop()办法后的链表为：n” + stuList);
// 在链表中再从新增加元素
stuList.push(stu2);
stuList.push(stu3);
System.out.println(“ 再次增加元素后的链表为：n” + stuList);
// 调用 poll()办法
System.out.println(“ 调用 poll()办法输入元素 ” + stuList.poll());
// 调用 poll()办法将获取元素的同时从链表中删除了元素
System.out.println(“ 调用 poll()办法后的链表为：n” + stuList);
}
}

运行后果

Set 是元素无序并且不能够反复的汇合，被称为集

HashSet 是 Set 的一个重要实现类, 称为哈希集
HashSet 中的元素无序并且不能够反复
HashSet 中只容许一个 null 元素
具备良好的存取和查找性能

Set

HashSet

Iterator 接口能够以对立的形式对各种汇合元素进行遍历
hasNext() 办法检测汇合中是否还有下一个元素
next() 办法返回汇合中的下一个元素

迭代器遍历流程
–实现办法 for 循环和 while 循环

HashSet 存储多个示意色彩的英文单词，并输入
单词包含“blue”、“red”、“black”、” yllow” 和“white”
应用 add()办法迭代器 Iterator

package com.sh.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class WordDemo {
public static void main(String[] args) {
// 将英文单词增加到 HashSet 中
Set set = new HashSet();
// 向汇合中增加元素
set.add(“blue”);
set.add(“red”);
set.add(“black”);
set.add(“yellow”);
set.add(“white”);
// 显示汇合的内容
System.out.println(“ 汇合中的元素为：”);
Iterator it = set.iterator();
// 遍历迭代器并输入元素
while (it.hasNext()) {
System.out.print(it.next() + ” “);
}
// for(Iterator<Set> it1=set.iterator();it1.hasNext();) {
// System.out.println(it1.next());
// }
System.out.println();
// 在汇合中插入一个新的单词
// set.add(“green”);
set.add(“white”);
it = set.iterator();
// 遍历迭代器并输入元素
System.out.println(““);
System.out.println(“ 插入反复元素后的输入后果为：”);
while (it.hasNext()) {
System.out.print(it.next() + ” “);
}
// 插入失败，然而不会报错
}
}

需要
– 增加和显示宠物猫信息
– 查找某只宠物猫的信息并输入
– 批改宠物猫的信息
– 删除宠物猫信息
属性
–名字 name
–年龄 month
–种类 species
办法
–构造方法
–获取和设置属性值的办法
–其余办法 hashCode 和 equals
–查找办法

哈希表和一般存储序列（哈希表能够进步数据查找速度）

哈希表分三个 (多个) 区域来存放数据，什么数据放到哪个区域有一的规定（hashCode）

判断属于哪个区域用 hashCode 办法
判断某个区域对象是否是咱们所要找的，用 equals 办法

package com.sh.set;
public class Cat {
private String name; // 名字
private int month; // 年龄
private String species;// 种类
// 构造方法
public Cat(String name, int month, String species) {
super();
this.name = name;
this.month = month;
this.species = species;
}
//getter 与 setter 办法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
@Override
public String toString() {
return “[姓名：” + name + “, 年龄：” + month + “, 种类：” + species + “]”;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + month;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((species == null) ? 0 : species.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
// 判断对象是否相等，相等则返回 true，不必持续比拟属性了
if(this==obj)
return true;
// 判断 obj 是否是 Cat 类的对象
if(obj.getClass()==Cat.class){
Cat cat=(Cat)obj;
return cat.getName().equals(name)&&(cat.getMonth()==month)&&(cat.getSpecies().equals(species));
}
return false;
}
}
// 测试类
package com.sh.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CatTest {
public static void main(String[] args) {
// 定义宠物猫对象
Cat huahua = new Cat(“ 花花 ”, 12, “ 英国短毛猫 ”);
Cat fanfan = new Cat(“ 凡凡 ”, 3, “ 中华田园猫 ”);
// 将宠物猫对象放入 HashSet 中
Set<Cat> set = new HashSet<Cat>();
set.add(huahua);
set.add(fanfan);
// 显示宠物猫信息
Iterator<Cat> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
// 再增加一个与花花属性一样的猫
Cat huahua01 = new Cat(“ 花花 ”, 12, “ 英国短毛猫 ”);
set.add(huahua01);
System.out.println(““);
System.out.println(“ 增加反复数据后的宠物猫信息：”);
it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println(““);
// 从新插入一个新宠物猫
Cat huahua02 = new Cat(“ 花花二代 ”, 2, “ 英国短毛猫 ”);
set.add(huahua02);
System.out.println(“ 增加花花二代后的宠物猫信息：”);
it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println(““);
// 在汇合中查找花花的信息并输入
if (set.contains(huahua)) {
System.out.println(“ 花花找到了！”);
System.out.println(huahua);
} else {
System.out.println(“ 花花没找到！”);
}
// 在汇合中应用名字查找花花的信息
System.out.println(““);
System.out.println(“ 通过名字查找花花信息 ”);
boolean flag = false;
Cat c = null;
it = set.iterator();
while (it.hasNext()) {
c = it.next();
if (c.getName().equals(“ 花花 ”)) {
flag = true;// 找到了
break;
}
}
if (flag) {
System.out.println(“ 花花找到了 ”);
System.out.println(c);
} else {
System.out.println(“ 花花没找到 ”);
}
// 删除花花二代的信息并从新输入
for (Cat cat : set) {
if (“ 花花二代 ”.equals(cat.getName())) {
set.remove(cat);
break;
}
}
System.out.println(““);
System.out.println(“ 删除花花二代后的数据 ”);
for(Cat cat:set){
System.out.println(cat);
}
// 删除汇合中的所有宠物猫信息
System.out.println(““);
boolean flag1=set.removeAll(set);
if(set.isEmpty()){
System.out.println(“ 猫都不见了。。。”);
}else{
System.out.println(“ 猫还在。。。”);
}
}
}

运行截图

关于java:我在上海乐字节学习Java的第二十天持续更新中

Java 汇合框架体系结构

List(列表)

ArrayList

案例一

案例二（布告治理）

LinkedList

案例一：应用 LinkedList 对字符串进行治理

案例二：应用 LinkedList 对自定义类进行治理

Set

HashSet

TreeSet（具体能够查看 API 文档）

Iterator(迭代器)

案例一

案例二（宠物猫信息管理）

hashCode 和 equals

Just My Socks（注册教程内含优惠码）

关于java:我在上海乐字节学习Java的第二十天持续更新中

Java 汇合框架体系结构

List(列表)

ArrayList

案例一

案例二（布告治理）

LinkedList

案例一：应用 LinkedList 对字符串进行治理

案例二：应用 LinkedList 对自定义类进行治理

Set

HashSet

TreeSet（具体能够查看 API 文档）

Iterator(迭代器)

案例一

案例二（宠物猫信息管理）

hashCode 和 equals

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）