Set（散列）
无序
不能存储重复元素
实现类：HasSet、LinkedHashSet、TreeSet
HashSet
底层基于HashMap（基于数组+链表）实现数组存储，不能存储重复元素，不能保证元素存储的顺序恒久不变。默认的初始容量为16，默认加载因子为0.75，每次扩容是在原来的基础上增加一倍。线程不安全的集合。
加载因子越大，某个桶中的节点数越多导致查询效率降低
加载因子越小，进行频繁的扩容与rehash操作，导致大量的内存在浪费。
当某个链表的长度大于8个时，在jdk1.8时会把链表扭转成二叉树进行存储
LinkedHashSet
记录下存储元素对象的位置（LinkedHashMap）
package cn.tedu.collection.set;
import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
public static void main(String[] args) {
//创建对象
LinkedHashSet<String> set=new LinkedHashSet<>();
//添加元素
set.add("bc");
set.add("ac");
set.add("bc");
set.add("1abc");
set.add("a2bc");
set.add("abc3");
//
System.out.println(set);
}
}
TreeSet
默认给存储元素对象进行排序
类实现Comparable接口产生对象才能存储到TreeSet中，需要指定排序规则（重写compareTo方法），才能进行排序
package cn.tedu.collection.set;
import java.io.Serializable;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
/*//创建集合对象
TreeSet<String> t=new TreeSet<>();
//添加元素
t.add("abc");
t.add("bc");
t.add("ac");
t.add("ab");
t.add("1abc");
t.add("a2bc");
//默认给存储元素对象进行排序---升序排序
System.out.println(t);*/
//创建对象
TreeSet<Hero> t=new TreeSet<>();
//添加元素
t.add(new Hero("鲁班",'男',18888));
t.add(new Hero("后羿",'男',28888));
t.add(new Hero("妲己",'女',19888));
t.add(new Hero("明世隐",'男',18000));
t.add(new Hero("瑶",'女',38000));
//ClassCastException---类型转换异常
//System.out.println(t);
//遍历输出---集合对象
for (Hero s:t) {
System.out.println(s);
}
/*Iterator<Hero> s=t.iterator();
while (s.hasNext()){
String
}*/
}
}
//代表英雄的类
//只有类实现了Comparable接口产生对象才能存储到TreeSet集合中
class Hero implements Serializable,Comparable<Hero> {
//属性
String name;
char gender;
//英雄熟练度---分数
int score;
//有参构造
public Hero(String name,char gender,int score){
this.name=name;
this.gender=gender;
this.score=score;
}
//重写toString方法
@Override
public String toString() {
return "Hero{" +
"name='" + name + '\'' +
", gender=" + gender +
", score=" + score +
'}';
}
//指定排序规则
//如果返回值是整数表面前面对象大于后面对象
//如果返回值是整数表面前面对象小于后面对象
//如果返回值是0表面前面对象等于后面对象
@Override
public int compareTo(Hero o) {//重写的方法
//根据英雄的分数来给对象进行排序---降序
return o.score-this.score;
}
}
Queue（队列）
遵循先进先出的原则
队头元素—第一个存放元素
队尾元素—最后一个存放元素
package cn.tedu.collection.queue;
import java.util.LinkedList;
import java.util.Queue;
public class QueueDemo {
public static void main(String[] args) {
//创建队列对象
Queue<String> q=new LinkedList<>();
//
//获取队头元素但是并不删除
//没有元素（报错）---NoSuchElementException
//System.out.println(q.element());
//获取队头元素但是并不删除
//没有元素---返回null
System.out.println(q.peek());
}
}
泛型
参数化类型，jdk1.5新特性
当泛型指定成确切类型时后续只能操作对应类型数据—泛型擦除（编译时期）
泛型的上下限
上限<? extends 类/接口>—可以接收类以及子类/接口以及子接口
下限<? super 类/接口>—可以接收类以及父类/接口以及父接口
package cn.tedu.type;
import com.sun.org.apache.xerces.internal.xs.StringList;
import java.util.ArrayList;
import java.util.List;
public class TypeDemo1 {
public static void main(String[] args) {
//创建集合对象
//当不使用泛型时存储数据很方便但是获取数据进行操作时就很复杂
List list=new ArrayList();
//三种效果一样，推荐使用方式---jdk1.7
List<String> list1=new ArrayList<>();
List list2=new ArrayList<String>();
List<String> list3=new ArrayList<String>();
//泛型指定元素类型（默认可以指定成所有的引用类型）
//当泛型类型指定之后后续操作时都是使用指定类型---泛型擦除（编译时期）
list1.add("abc");
list1.add("");
list1.add("");
list1.add("");
list1.add("");
list1.add("");
//添加元素
//没有泛型的指定---可以存储任意类型的数据
//存储数据很灵活
list.add(123);
list.add(true);
list.add("abc");
list.add('a');
//获取集合元素对象
//Object所有数据类型
//取出数据时需要确定具体类型---操作复杂
for (Object s:list) {
//判断元素对象具体是哪个类型
if (s instanceof Integer) {
Integer in= (Integer) s;
}else if(s instanceof Boolean){
Boolean b= (Boolean) s;
}else if(s instanceof String){
String b= (String) s;
}else {
Character c= (Character) s;
}
System.out.println(s);
}
}
}
package cn.tedu.type;
import java.util.ArrayList;
import java.util.List;
public class TypeDemo2 {
public static void main(String[] args) {
//List<Number> list=new ArrayList<Integer>();
//泛型没有向上造型
List<Integer> list1=new ArrayList<>();
list1.add(123);
list1.add(23);
list1.add(13);
list1.add(12);
list1.add(1233);
List<Double> list2=new ArrayList<>();
list2.add(12.45);
list2.add(1.245);
list2.add(2.415);
list2.add(2.4);
list2.add(2.451);
List<String> list3=new ArrayList<>();
list3.add("abc");
list3.add("bc");
list3.add("ac");
list3.add("ab");
//调用方法
m(list1);
m(list2);
//m(list3);
}
//定义方法来遍历所有元素类型时数值类型集合对象
//?代表泛型可以指定的类
//<? extends Number>---可以接受Number类以及子类
//<? extends 类/接口>---可以接收类以及子类/接口以及子接口
//泛型的上限
public static void m(List<? extends Number> list){//=new ArrayList<Integer>()
for (Object i:list) {
System.out.println(i);
}
}
//List<? super String>---可以接受String类以及父类
//List<? super 类/接口>---可以接收类以及父类/接口以及父接口
//泛型的下限
public static void n(List<? super String> list){
for (Object i:list) {
System.out.println(i);
}
}
}
映射（Map<K，V>）
存储有关系（映射关系）的数据的容器
K代表键，V代表值，键不能重复，值可以重复，由键得到对应值，映射是由多个键和多个值来组成
可以把键和值看成键值对，就可以把每个键值对看做成对象，可以把键值对抽取成类（Entry）来表示，Entry产生的每个对象就是一个具体键值对，映射由多个键值对来组成
package cn.tedu.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo1 {
public static void main(String[] args) {
//创建映射对象
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("abc",123);
map.put("bc",23);
map.put("ac",13);
map.put("ab",12);
map.put("1abc",1123);
map.put("a2bc",1223);
map.put("ab3c",1233);
//键不能重复，会舍弃掉新的键更新为新的值
map.put("ab3c",1333);
//清空映射
//map.clear();
//判断是否包含键/值
//System.out.println(map.containsKey("abc"));
//System.out.println(map.containsValue(456));
//把映射中所有键值对放到Set集合中
//Map.Entry<String,Integer>---代表键值对类型
//Set<Map.Entry<String,Integer>> S=map.entrySet();
//由键来获取值
//System.out.println(map.get("abc"));
//判断映射是否为空
//System.out.println(map.isEmpty());
//把映射中所有的键放到Set集合中
//Set<String> set=map.keySet();
//删除元素
//根据键来删除值对
//map.remove("abc");
//保证键和值存在才能删除键值对
//map.remove("abc",1223);
//返回键值对的个数
//System.out.println(map.size());
//把映射中所有的值放到集合中
//Collection<Integer> c=map.values();
//无序
//底层由键来确定存储位置，键无序的导致键值也是无序的
System.out.println(map);
}
}
映射遍历
1.获取所有的键再获取对应的值
2.获取所有的键值对再获取键和值
package cn.tedu.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo2 {
public static void main(String[] args) {
//创建映射对象
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("abc",123);
map.put("bc",23);
map.put("ac",13);
map.put("ab",12);
map.put("1abc",1123);
map.put("a2bc",1223);
map.put("ab3c",1233);
//获取所有的键
Set<String> set=map.keySet();
//遍历Set集合
for (String s:set) {
//由键获取值
System.out.println(s+"="+map.get(s));
}
}
}
package cn.tedu.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo3 {
public static void main(String[] args) {
//创建映射对象
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("abc",123);
map.put("bc",23);
map.put("ac",13);
map.put("ab",12);
map.put("1abc",1123);
map.put("a2bc",1223);
map.put("ab3c",1233);
/* //获取所有的键值对
Set<Map.Entry<String,Integer>> set=map.entrySet();
//遍历Set集合
for (Map.Entry<String,Integer> m:set) {
//获取键和值
//System.out.println(m);
System.out.println(m.getKey()+"="+m.getValue());
}*/
//常用
for (Map.Entry<String,Integer> m: map.entrySet()) {
//获取键和值
//System.out.println(m);
System.out.println(m.getKey()+"="+m.getValue());
}
}
}
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
