- List集合&Set集合&Map集合
- 一、List集合
- 1.1.1增删改查
- 1.1.2 Arrylist与LinkedList的区别
- 1.2、List集合的三种遍历方式
- 1.3、Linkedlist 中堆栈及队列
- 1.4、List集合去重
- 1.5、List集合增长因子论证、List集合如何去优化
- 二、Set集合
- 2.1.1Set集合的基本特点
- 2.1.2遍历方式
- 2.2、Set集合的去重原理
- 2.3、自然排序接口及比较器接口
- 2.4.案例
- 三、Map集合
- 3.1.1.Map集合的特点
- 3.1.2.Map集合的增删改查及遍历方法
- 3.2、HashMap的实际开发
- 3.2.1.统计随机生成的字符出现的次数
- 3.3、泛型
- 3.3.1.为什么要使用泛型
一、List集合 1.1.1增删改查
package com.tft.temp;
import java.util.ArrayList;
import java.util.List;
public class Demo01 {
public static void main(String[] args) {
//创建一个list集合
List list =new ArrayList<>();
//给集合里面增加值
list.add("zs");
list.add("li");
list.add("tft");
list.add("ww");
list.add("pp");
//输出
System.out.println("增加后的集合："+list);
//修改
list.set(0, "hh");
System.out.println("修改后的集合"+list);
//删除
String remove = list.remove(1);
System.out.println("根据下标被删除的内容"+remove);
System.out.println("删除后的内容"+list);
}
}
1.1.2 Arrylist与LinkedList的区别
- Arrylist：特点： ArrayList底层是数组
- LinkedList：特点：Linkedlist的底层是链表
注意：遍历里面不能进行remove删除 ，会报当前改变异常
public class Demo01 {
public static void main(String[] args) {
//创建一个list集合
List list =new ArrayList<>();
//给集合里面增加值
list.add("zs");
list.add("li");
list.add("tft");
list.add("ww");
list.add("pp");
//第一种方式:for循环输出
for (int i = 0; i < list.size(); i++) {
System.out.println("使用for循环输出:"+list.get(i));
}
//第二种方式:for循环加强方式输出
for (String str : list) {
System.out.println("使用for循环加强输出："+str);
}
//第三种方式:Iterator迭代器输出
Iterator iterator = list.iterator();
//判断是否有下一个值
while(iterator.hasNext()) {//代表有就执行下一步
System.out.println("迭代器输出:"+iterator.next());//输出
}
}
}
1.3、Linkedlist 中堆栈及队列
- 堆栈:特点: 先进后出
- 队列:特点:先进先出
public class Demo03 {
public static void main(String[] args) {
//开始测试 队列
duilie dl=new duilie(new LinkedList<>());
//调用增加的方法
dl.push("zs");
dl.push("ls");
dl.push("hh");
dl.push("dd");
//开始取出
System.out.println("================");
System.out.println(dl.pop());
System.out.println(dl.pop());
System.out.println(dl.pop());
System.out.println(dl.pop());
//开始测试 堆栈
duizhan dz=new duizhan(new LinkedList<>());
//调用增加的方法
dz.push("zs1");
dz.push("ls1");
dz.push("we1");
dz.push("mz1");
//开始取出
System.out.println("================");
System.out.println(dz.pop());
System.out.println(dz.pop());
System.out.println(dz.pop());
System.out.println(dz.pop());
}
}
//创建一个队列类
class duilie{
private LinkedList list;
//增加元素的方法
public void push(String list) {
this.list.add(list);
}
//移除元素的方法（取出/出去）
public String pop() {
return this.list.remove();
}
public LinkedList getList() {
return list;
}
public void setList(LinkedList list) {
this.list = list;
}
public duilie(LinkedList list) {
super();
this.list = list;
}
@Override
public String toString() {
return "duilie [list=" + list + "]";
}
public duilie() {
}
}
//创建一个堆栈类
class duizhan{
private LinkedList list;
//增加元素的方法
public void push(String list) {
this.list.add(list);
}
//移除元素的方法（取出/出去）
public String pop() {
return this.list.removeLast();//从最后一个开始取出即可(删除的对象)
}
public LinkedList getList() {
return list;
}
public void setList(LinkedList list) {
this.list = list;
}
public duizhan(LinkedList list) {
super();
this.list = list;
}
@Override
public String toString() {
return "duilie [list=" + list + "]";
}
public duizhan() {
super();
}
}
1.4、List集合去重
注意：底层是是重写eq方法来执行去重元素
public class Demo04 {
public static void main(String[] args) {
//案例一 创建集合 增加五个元素 要求去重并且只输出去重后的元素
List list=new ArrayList<>();
//新增一个集合 来保存去重后的元素
List oldList=new ArrayList<>();
//开始增加
list.add("张三");
list.add("李四");
list.add("王二");
list.add("张三");
System.out.println("去重前"+list);
//开始去重
//遍历
for (String string : list) {
//判断如果新集合不包含老集合的元素就增加到新集合
if(!oldList.contains(string)) {
oldList.add(string);
}
}
System.out.println("去重后"+oldList);
}
}
1.5、List集合增长因子论证、List集合如何去优化
- list集合底层是数组
- list集合底层数组的初始化容量是10、增长因子是0.5
- list集合进行优化、只需要扩大初始化容量、减少扩容的次数、进一步提到性能
- 数组的长度是不可变的、可list集合为何能无限制的添加元素？ 答:数组容量达到上限会进行扩容
二、Set集合 2.1.1Set集合的基本特点
- 容器中是不会出现重写的元素
- set相对于List集合，是没有下标的
- 增强的for
- 迭代器
- hashSet底层，与hashcode，equals方法相关
- hashset底层去重：就是与hashcode和equals方法相关(重写hashcode和equals方法)
2、优先执行hashcode，再执行equals。当hashcode相同且equals为true，才会判定为相同元素
注：① hashcode相同，才会执行equals
② hashlode不同，不会执行equals
- treeset相较于hashset是可以进行排序的
- treeSet中的元素想要排序，那么必须实现java.lang.Comparable接口
public class Demo3 {
public static void main(String[] args) {
//1.需求 按照字母来排序
treeset相较于hashset是可以进行排序的
// TreeSet set = new TreeSet<>();
//
// set.add("zs");
// set.add("pz");
// set.add("tfz");
// set.add("jmh");
// System.out.println(set);
//2. 排序的不是string属性，而是对象person
//treeSet中的元素想要排序，那么必须实现java.lang.Comparable接口
// TreeSet set =new TreeSet<>();
// person p1= new person("张三", 11,7000);
// person p2= new person("李四", 28,9000);
// person p3= new person("王五", 22,4000);
// set.add(p1);
// set.add(p2);
// set.add(p3);
// for (person ps : set) {
// System.out.println(ps);
// }
//针对不同的模块，有不同排序规则，相互之间互不干扰，针对于同一批数据
//注意 当比较器参与排序，那么此时自然排序接口java.lang.Comparable接口就失效了
//用户管理模板
// TreeSet set = new TreeSet<>(new Comparator() {
// @Override
// public int compare(person o1, person o2) {
// return o1.getName().compareTo(o2.getName());
// }
// });//用户管理模板
//左边：接口实现方法的参数列表-> 右边：实现方法的方法体
// TreeSet set =new TreeSet<>((o1,o2)-> (int) (o2.getSalary()-o1.getSalary()));//薪资模块
TreeSet set =new TreeSet<>((x,y)->x.getAge()-y.getAge());//储备干部管理模块
person p1= new person("张三", 11,7000);
person p2= new person("李四", 28,9000);
person p3= new person("王五", 22,4000);
set.add(p1);
set.add(p2);
set.add(p3);
for (person ps : set) {
System.out.println(ps);
}
}
}
class person implements Comparable{
private String name;
private int age;
private float salary;
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 float getSalary() {
return salary;
}
public void setSalary(float salary) {
this.salary = salary;
}
@Override
public String toString() {
return "person [name=" + name + ", age=" + age + ", salary=" + salary + "]";
}
public person(String name, int age, float salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}
public person() {
// TODO Auto-generated constructor stub
}
@Override
public int compareTo(person o) {
return (int) (this.salary - o.salary);
}
}
三、Map集合
3.1.1.Map集合的特点
特点：保存的方式，是以键值对的形式存在
3.1.2.Map集合的增删改查及遍历方法
public class Demo1 {
public static void main(String[] args) {
HashMap map = new HashMap<>();
//增加
map.put("张三",15);
map.put("李四",16);
map.put("王五",17);
map.put("老刘",18);
System.out.println(map);
//删除
Object remove = map.remove("老刘");
System.out.println(remove);
//修改 修改的本质就是通过key的键去覆盖之前value值
Object put = map.put("张三",11);
System.out.println(put+"");
//遍历map集合的方式
//方式一：先获取map集合中的key键，然后在将其遍历得到单个key，最后通过单个key拿到对应的值
Set set = map.keySet();
for (String s : set) {
System.out.println("key的键是"+s+"value的值是"+map.get(s));
}
//方式二：先拿到map集合对应的映射关系entry对象，然后通过entry对象，挨个拿到key以及value的值
Set> entrySet = map.entrySet();
for (Entry entry : entrySet) {
System.out.println("当前key的键为"+entry.getKey()+"当前value的值为"+entry.getValue());
}
}
}
3.2、HashMap的实际开发
3.2.1.统计随机生成的字符出现的次数
- 将字符转化为字符数组
- 遍历字符数组，将遍历的字符当做key,在map集合找对应的值
- 值为空，代表这个字符从来没有在这个map容器中出现过，给容器map赋值为1
- 值不为空，代表曾经出现过，那么给原有对应值+1，覆盖原有的值
- 没有使用之前：编译通过的代码可能会在运行时产生异常，代码健壮性差
- 使用之后：将代码运行时的异常转换为编译期的错误，增强了代码的健壮性
