本文详细介绍了Java集合框架中的ArrayList和LinkedList的存储结构、特性和适用场合，强调了它们在增删改查操作上的区别。同时，对比了两者在频繁插入操作时的性能。此外，还探讨了HashSet的特点、遍历方式和hash算法，并展示了HashMap的遍历方法和实际应用。最后，简要阐述了泛型的概念和使用示例。
目录
三.比较ArrayList和LinkedList频繁插入的时间
一.ArrayList
1.存储结构
ArrayList (顺序表：插入有序，输出有序)，实现了长度可变的数组。
在内存中分配了连续的内存空间
遍历元素和随机访问元素的效率比较高。
2.特性
1.元素不唯一，可以放重复的数据
2.元素具有下标，导致随机访问元素的效率比较高。
3、保证元素添加时的顺序与输出的顺序相同。
3.适用场合
遍历元素和随机访问元素的场合。
4.缺点
不适用场合：频繁插入和删除操作的场合。
5.简单增删改查
package com.gongsi.cn.oa.work806.test1;
import java.util.ArrayList;
public class TestArrayList {
public static void main(String[] args) {
//可变长的数组，底层就是用数组做的
ArrayList arrayList=new ArrayList();
System.out.println("=========增加=========");
// 增加
arrayList.add("咖啡害人不浅");
arrayList.add("不要再胡作非为");
arrayList.add("健康的肚子");
// 查 输出
for (Object a : arrayList) {
System.out.println(a);
}
System.out.println("=========删除=========");
// 删除
arrayList.remove("咖啡害人不浅");
//arrayList.remove(0);//移除"咖啡害人不浅"后，就从"不要再胡作非为"开始了
for (Object a : arrayList) {
System.out.println(a);
}
System.out.println("=========改=========");
// 改
arrayList.set(0, "肚子疼你走开！！！");
for (Object a : arrayList) {
System.out.println(a);
}
}
}
6.练习题
package com.gongsi.cn.oa.work806.test2;
public class Staff {
private int no;
private String name;
private int age;
private String hireday;
@Override
public String toString() {
return "Staff [no=" + no + ", name=" + name + ", age=" + age + ", hireday=" + hireday + "]";
}
public Staff() {
super();
}
public Staff(int no, String name, int age, String hireday) {
super();
this.no = no;
this.name = name;
this.age = age;
this.hireday = hireday;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
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 String getHireday() {
return hireday;
}
public void setHireday(String hireday) {
this.hireday = hireday;
}
}
package com.gongsi.cn.oa.work806.test2;
import java.util.ArrayList;
public class TestStaff {
public static void main(String[] args) {
ArrayList staff=new ArrayList();
staff.add(new Staff(01, "张三", 18, "20210805"));
staff.add(new Staff(01, "李四", 19, "20210806"));
staff.add(new Staff(01, "王五", 21, "20210805"));
System.out.println("所有员工的姓名为：");
long num=staff.size();
for (Object object : staff) {//测试看的
System.out.println(object);
}
//实际用的
for (Object staf : staff) {
Staff s=(Staff)staf;//先强转
System.out.println(s.getName()+"\t"+s.getAge()+"\t"+s.getAge()+"\t"+s.getHireday());
}
}
}
二.LinkedList
1.存储结构：双链表
插入、删除元素时效率比较高
2.特性
1.不唯一的数据（可重复）
2.没有明确下标，只通过挨个循环找下标，所以访问元素效率低。
3.保证元素添加时的顺序与输出的顺序相同
3.应用场合
插入、删除元素的效率比较高 5
4.ArrayList缺点是什么
不适于频繁查找操作的场合
5.简单增删改查
package com.gongsi.cn.oa.work806.test1;
import java.util.LinkedList;
public class TestLinkedList {
public static void main(String[] args) {
//可变长的数组，底层就是用数组做的
LinkedList arrayList=new LinkedList();
System.out.println("=========增加=========");
// 增加
arrayList.add("咖啡害人不浅");
arrayList.add("不要再胡作非为");
arrayList.add("健康的肚子");
// 查 输出
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
// for (Object a : arrayList) {
// System.out.println(a);
// }
System.out.println("=========删除=========");
// 删除
arrayList.remove("咖啡害人不浅");
//arrayList.remove(0);//移除"咖啡害人不浅"后，就从"不要再胡作非为"开始了
for (Object a : arrayList) {
System.out.println(a);
}
System.out.println("=========改=========");
// 改
arrayList.set(0, "肚子疼你走开！！！");
for (Object a : arrayList) {
System.out.println(a);
}
}
}
6.LinkedList常用方法
package com.gongsi.cn.oa.work806.test1;
import java.util.LinkedList;
public class TestLinkedList {
public static void main(String[] args) {
//可变长的数组，底层就是用数组做的
LinkedList arrayList=new LinkedList();
System.out.println("=========增加=========");
// 增加
arrayList.add("咖啡害人不浅");
arrayList.add("不要再胡作非为");
arrayList.add("健康的肚子");
arrayList.addFirst("快要去吃饭了");
arrayList.addLast("还真的有点饿了");
System.out.println("获得当前集合的第一个元素："+arrayList.getFirst());
System.out.println("获得当前集合的第一个元素："+arrayList.getLast());
System.out.println("移除并返回当前集合的第一个元素："+arrayList.removeFirst());
System.out.println("移除并返回当前集合的最后一个元素："+arrayList.removeLast());
// 查 输出
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
// for (Object a : arrayList) {
// System.out.println(a);
// }
// System.out.println("=========删除=========");
删除
// arrayList.remove("咖啡害人不浅");
// //arrayList.remove(0);//移除"咖啡害人不浅"后，就从"不要再胡作非为"开始了
// for (Object a : arrayList) {
// System.out.println(a);
// }
// System.out.println("=========改=========");
改
// arrayList.set(0, "肚子疼你走开！！！");
// for (Object a : arrayList) {
// System.out.println(a);
// }
}
}
7.LinkedList练习题
package com.gongsi.cn.oa.work806.test2;
public class Staff {
private int no;
private String name;
private int age;
private String hireday;
@Override
public String toString() {
return "Staff [no=" + no + ", name=" + name + ", age=" + age + ", hireday=" + hireday + "]";
}
public Staff() {
super();
}
public Staff(int no, String name, int age, String hireday) {
super();
this.no = no;
this.name = name;
this.age = age;
this.hireday = hireday;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
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 String getHireday() {
return hireday;
}
public void setHireday(String hireday) {
this.hireday = hireday;
}
}
package homework1;
import java.util.LinkedList;
import java.util.Scanner;
public class TestStaff {
public static void main(String[] args) {
LinkedList<Staff> staff=new LinkedList<Staff>();
Staff staff2=new Staff();
Scanner scanner=new Scanner(System.in);
//老员工
staff.add(new Staff(01, "张三", 18, "20210805"));
staff.add(new Staff(02, "李四", 19, "20210806"));
staff.add(new Staff(03, "王五", 21, "20210805"));
staff.add(new Staff(04, "赵六", 21, "20211005"));
System.out.println("记录员工信息请输入1");
System.out.println("移除员工信息请输入2");
System.out.println("退出请输入0");
System.out.print("请输入：");
int chance=scanner.nextInt();
if (chance==1) {
// 员工入职
System.out.println("新员工入职登录表:");
System.out.print("编号：");
int no=scanner.nextInt();
staff2.setNo(no);
System.out.print("姓名：");
String name=scanner.next();
staff2.setName(name);
System.out.print("年龄：");
int age=scanner.nextInt();
staff2.setAge(age);
System.out.print("入职时间：");
String hireday=scanner.next();
staff2.setHireday(hireday);
staff.add(staff2);
System.out.println("更新成功！");
for (Staff object : staff) {
System.out.println(object);
}
}
if (chance==2) {
// 员工离职
System.out.println("目前员工信息表：");
for (Staff object : staff) {
System.out.println(object);
}
System.out.print("请选择你要移除的员工(第几个)：");
int levelNo=scanner.nextInt();
staff.remove(levelNo-1);
System.out.println("移除成功！");
for (Staff object : staff) {
System.out.println(object);
}
}
if (chance==0) {
return;
}
}
}
三.比较ArrayList和LinkedList频繁插入的时间
package com.gongsi.cn.oa.work806.test1;
import java.util.ArrayList;
import java.util.LinkedList;
public class Test {
public static void main(String[] args) {
ArrayList arrayList=new ArrayList();
arrayList.add("新闻000");
arrayList.add("新闻001");
long starTime=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
arrayList.add(1, "新闻"+i);
}
long endTime=System.currentTimeMillis();
System.out.println("arrayList频繁插入的使用时间是："+(endTime-starTime));
LinkedList likLinkedList=new LinkedList();
likLinkedList.add("新闻000");
likLinkedList.add("新闻001");
starTime=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
likLinkedList.add(1, "新闻"+i);
}
endTime=System.currentTimeMillis();
System.out.println("LinkedList频繁插入的使用时间是："+(endTime-starTime));
}
}
四.遍历集合的方法
1.for get（i）
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}2.foreach
for (String string : arrayList) {
System.out.println(string);
}3.Interator迭代器迭代
Iterator it=arrayList.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}五.hashset
1.特点
1）存储一组唯一，无序的元素。
2）查询速度最高，线性表+单链表结构。
3）hashset没有下标 无法get（i）
2.如何遍历
1）foreach
2）迭代器：（Iterator） 可以遍历所有的集合
3.hash算法
4.练习
package com.gongsi.cn.oa.work806.test1;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class TestHashSet {
public static void main(String[] args) {
HashSet<String> hashSet=new HashSet<String>();
hashSet.add("新闻111");
hashSet.add("新闻222");
hashSet.add("新闻333");
hashSet.add("新闻444");
hashSet.add("新闻555");
hashSet.add("新闻666");
hashSet.add("新闻666");
// 遍历集合：foreach Interator
// 不可以 hashset没有下标 无法get（i）
// for (int i = 0; i < hashSet.size(); i++) {
// System.out.println(hashSet.get(i));
// }
for (Object n : hashSet) {
System.out.println(n);
}
System.out.println("===============");
//使用迭代器遍历
Iterator it=hashSet.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
有两个“新闻666”，只显示一个
六.HashMap<K,V>
1.怎么遍历
1）得到key的集合 keySet()
2）foreach遍历 get(key)
2.例子
package com.gongsi.cn.oa.work806.test1;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Map.Entry;
import java.util.Set;
public class TestHashMap {
public static void main(String[] args) {
/*
* cn 中国
* Jp 日本
* us 美国
* uk 英国
* HashSet 底层就是HashMap
* 保存key value 键值对
* */
HashMap<String,String> hashMap=new HashMap<String,String>();
hashMap.put("cn", "中国");
hashMap.put("jp", "日本");
hashMap.put("us", "美国");
hashMap.put("uk", "英国");
//根据key 得到value 获得value值:hashMap.get(key) hashMap.values()
Scanner scanner=new Scanner(System.in);
String value=(String) hashMap.get("cn");
System.out.println(value);
// //泛型的使用1 棒打鸳鸯
// System.out.println("==========棒打鸳鸯============");
// Set<Entry<String, String>> sets=hashMap.entrySet();
// for (Entry<String, String> entry : sets) {
// System.out.println(entry.getKey()+"===>"+entry.getValue());
// }
//怎么遍历 1.得到key的集合 2.foreach遍历
System.out.println("=================");
Set keys=hashMap.keySet();
for (Object key : keys) {
System.out.println(key+"===>"+hashMap.get(key));
}
System.out.println("============key值和value值分开输出=============");
Collection values=hashMap.values();
for (Object key : keys) {
System.out.println(key);
}
for (Object v : values) {
System.out.println(v);
}
}
}
3.练习
功能实现： *查找书名：1
* 查找成功：显示诗的内容。是否还想再次查找？
* Y：再次查找
* N:退出
* 查找失败:是否还想再次查找？
* Y：再次查找
* N:退出
退出：exit
package homework2;
import java.util.jar.Attributes.Name;
public class Poem {
private String name;
private String author;
private String content;
@Override
public String toString() {
System.out.println("====================================================");
return "诗名《" + name +"》"+"\n"+ "作者：" + author + "\n "+"全文：" + content;
}
public Poem() {
super();
}
public Poem(String name) {
super();
this.name = name;
}
public Poem(String name, String author, String content) {
super();
this.name = name;
this.author = author;
this.content = content;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
package homework2;
import java.util.HashMap;
import java.util.Scanner;
/*
*查找书名：1
* 查找成功：显示诗的内容。是否还想再次查找？
* Y：再次查找
* N:退出
* 查找失败:是否还想再次查找？
* Y：再次查找
* N:退出
退出：exit
* */
public class TestPoem {
public static void main(String[] args) {
HashMap<String, Poem> hashMap = new HashMap<String, Poem>();
hashMap.put("出塞", new Poem("出塞", "王昌龄", "秦时明月汉时关，万里长征人未还。但使龙城飞将在，不教胡马度阴山。"));
hashMap.put("春晓", new Poem("春晓", "孟浩然", "春眠不觉晓，处处闻啼鸟。夜来风雨声，花落知多少。 "));
hashMap.put("早发白帝城", new Poem("早发白帝城", "李白", "朝辞白帝彩云间，千里江陵一日还。两岸猿声啼不住，轻舟已过万重山。 "));
Scanner scanner = new Scanner(System.in);
System.out.println("按1：查找书名");
System.out.println("按exit：退出查找");
System.out.print("请输入：");
String input = scanner.next();
if (input.equals("1")) {
boolean r=true;
while (r) {
System.out.print("请输入您所要查询的诗的名字：");
String name = scanner.next();
if (name.equals("出塞") || name.equals("春晓") || name.equals("早发白帝城")) {
Poem value = hashMap.get(name);
System.out.println(value);
System.out.println("====================================================");
System.out.print("是否还要再次查找？（Y/N）：");
String yn=scanner.next();
if (yn.equals("Y")) {
continue;
}else {
break;
}
} else {
System.out.println("没有您所要查找的诗！");
System.out.println("是否还要再次查找？（Y/N）：");
String yn=scanner.next();
if (yn.equals("Y")) {
continue;
}else {
break;
}
}
}
}else if (input.equals("exit")) {
return ;
}
}
}
七.泛型
1.什么是泛型
参数化类型就是泛型
2.泛型的使用例子
1）遍历时不用再进行类型转换
package com.gongsi.cn.oa.work806.test1;
import java.util.ArrayList;
public class TestFanXin {
public static void main(String[] args) {
ArrayList<Studeng> arrayList1=new ArrayList<Studeng>();//这个集合只能存放Student类型的
arrayList1.add(new Studeng());
arrayList1.add(new Studeng());
arrayList1.add(new Studeng());
//遍历时不用再进行类型转换 (TestStaff中没有使用泛型时，就需要类型转换)
for (Studeng studeng : arrayList1) {
System.out.println(studeng);
}
ArrayList<Tiger> arrayList2=new ArrayList<Tiger>();//这个集合只能存放Tiger类型的
arrayList2.add(new Tiger());
arrayList2.add(new Tiger());
arrayList2.add(new Tiger());
//遍历时不用再进行类型转换
for (Tiger tiger : arrayList2) {
System.out.println(tiger);
}
}
}
class Studeng{}
class Tiger{}
2）通用模板 实现分页功能
package com.gongsi.cn.oa.work806.test3;
public class Info {
}
package com.gongsi.cn.oa.work806.test3;
public class Product {
}
package com.gongsi.cn.oa.work806.test3;
public class Student {
}
package com.gongsi.cn.oa.work806.test3;
//什么是泛型：参数化类型就是泛型，可以写通用代码
//泛型的分页类可以通用到如何项目中
public class Page<E> {
//这里的代码以后写
}
package com.gongsi.cn.oa.work806.test3;
//泛型 通用模板 实现分页功能
public class Test {
public static void main(String[] args) {
Page<Student> stuPage=new Page<Student>();
Page<Info> infoPage=new Page<Info>();
Page<Product> proPage=new Page<Product>();
}
}
3）泛型的深入例子
使用 WuZhong<k extends Animal,V extends Zhiwu> K、V为任意值
扫一扫
353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
